PlexSheep
/
neovim-confs
1
1
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

minimal: remove unnecessary plugins

This commit is contained in:
root 2023-09-10 00:55:35 +02:00
parent 94254ff65e
commit ae6d7a0f8d
58 changed files with 12 additions and 4946 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
init.lua
View File

@ -8,14 +8,14 @@ config.ensure_lazy()
require('lazy').setup(vim.tbl_extend('keep', config.user_lazy_opts(), { require('lazy').setup(vim.tbl_extend('keep', config.user_lazy_opts(), {
spec = { spec = {
{ import = 'plex.plugins' }, { import = 'plex.plugins' },
{ import = 'plex.plugins.extras.ui' }, -- { import = 'plex.plugins.extras.ui' },
{ import = 'plex.plugins.extras.treesitter' }, -- { import = 'plex.plugins.extras.treesitter' },
{ import = 'plex.plugins.extras.editor' }, -- { import = 'plex.plugins.extras.editor' },
{ import = 'plex.plugins.extras.org' }, -- { import = 'plex.plugins.extras.org' },
{ import = 'plex.plugins.extras.lang.go' }, -- { import = 'plex.plugins.extras.lang.go' },
{ import = 'plex.plugins.extras.lang.json' }, -- { import = 'plex.plugins.extras.lang.json' },
{ import = 'plex.plugins.extras.lang.python' }, -- { import = 'plex.plugins.extras.lang.python' },
{ import = 'plex.plugins.extras.lang.yaml' }, -- { import = 'plex.plugins.extras.lang.yaml' },
-- This will load a custom user lua/plugins.lua or lua/plugins/* -- This will load a custom user lua/plugins.lua or lua/plugins/*
config.has_user_plugins() and { import = 'plugins' } or nil, config.has_user_plugins() and { import = 'plugins' } or nil,

325
lua/plex/plugins/coding.lua
View File

@ -1,325 +0,0 @@
-- Plugins: Coding
-- https://github.com/rafi/vim-config
return {
-----------------------------------------------------------------------------
{
'hrsh7th/nvim-cmp',
event = 'InsertEnter',
dependencies = {
'hrsh7th/cmp-nvim-lsp',
'hrsh7th/cmp-buffer',
'hrsh7th/cmp-path',
'hrsh7th/cmp-emoji',
{ 'saadparwaiz1/cmp_luasnip', dependencies = 'L3MON4D3/LuaSnip' },
'andersevenrud/cmp-tmux',
},
opts = function()
local cmp = require('cmp')
local defaults = require('cmp.config.default')()
local luasnip = require('luasnip')
local function has_words_before()
if vim.bo.buftype == 'prompt' then
return false
end
local line, col = unpack(vim.api.nvim_win_get_cursor(0))
-- stylua: ignore
return col ~= 0 and vim.api.nvim_buf_get_lines(0, line - 1, line, true)[1]:sub(col, col):match('%s') == nil
end
return {
preselect = cmp.PreselectMode.None,
sorting = defaults.sorting,
experimental = {
ghost_text = {
hl_group = 'Comment',
},
},
snippet = {
expand = function(args)
require('luasnip').lsp_expand(args.body)
end,
},
sources = cmp.config.sources({
{ name = 'nvim_lsp', priority = 50 },
{ name = 'path', priority = 40 },
{ name = 'luasnip', priority = 30 },
}, {
{ name = 'buffer', priority = 50, keyword_length = 3 },
{ name = 'emoji', insert = true, priority = 20 },
{
name = 'tmux',
priority = 10,
keyword_length = 3,
option = { all_panes = true, label = 'tmux' },
},
}),
mapping = cmp.mapping.preset.insert({
-- <CR> accepts currently selected item.
-- Set `select` to `false` to only confirm explicitly selected items.
['<CR>'] = cmp.mapping({
i = function(fallback)
if cmp.visible() and cmp.get_active_entry() then
cmp.confirm({ select = false })
else
fallback()
end
end,
s = cmp.mapping.confirm({
select = true,
behavior = cmp.ConfirmBehavior.Replace,
}),
-- Do not set command mode, it will interfere with noice popmenu.
}),
['<S-CR>'] = cmp.mapping.confirm({
behavior = cmp.ConfirmBehavior.Replace,
select = true,
}),
['<C-Space>'] = cmp.mapping.complete(),
['<C-n>'] = cmp.mapping.select_next_item(),
['<C-p>'] = cmp.mapping.select_prev_item(),
['<C-d>'] = cmp.mapping.select_next_item({ count = 5 }),
['<C-u>'] = cmp.mapping.select_prev_item({ count = 5 }),
['<C-f>'] = cmp.mapping.scroll_docs(4),
['<C-b>'] = cmp.mapping.scroll_docs(-4),
['<C-c>'] = function(fallback)
cmp.close()
fallback()
end,
['<Tab>'] = cmp.mapping(function(fallback)
if cmp.visible() then
cmp.select_next_item()
elseif luasnip.jumpable(1) then
luasnip.jump(1)
elseif has_words_before() then
cmp.complete()
else
fallback()
end
end, { 'i', 's' }),
['<S-Tab>'] = cmp.mapping(function(fallback)
if cmp.visible() then
cmp.select_prev_item()
elseif luasnip.jumpable(-1) then
luasnip.jump(-1)
else
fallback()
end
end, { 'i', 's' }),
}),
formatting = {
format = function(entry, vim_item)
-- Prepend with a fancy icon from config lua/plex/config/init.lua
local icons = require('plex.config').icons
if entry.source.name == 'git' then
vim_item.kind = icons.git
else
local symbol = icons.kinds[vim_item.kind]
if symbol ~= nil then
vim_item.kind = symbol .. ' ' .. vim_item.kind
end
end
return vim_item
end,
},
}
end,
},
-----------------------------------------------------------------------------
{
'L3MON4D3/LuaSnip',
event = 'InsertEnter',
dependencies = { 'rafamadriz/friendly-snippets' },
build = (not jit.os:find('Windows'))
and "echo 'jsregexp is optional, so not a big deal if it fails to build'; make install_jsregexp"
or nil,
-- stylua: ignore
keys = {
{
'<C-l>',
function() require('luasnip').expand_or_jump() end,
mode = { 'i', 's' },
},
},
opts = {
-- Don't store snippet history for less overhead
history = false,
-- Event on which to check for exiting a snippet's region
region_check_events = 'InsertEnter',
delete_check_events = 'InsertLeave',
ft_func = function()
return vim.split(vim.bo.filetype, '.', { plain = true })
end,
},
config = function(_, opts)
require('luasnip').setup(opts)
require('luasnip.loaders.from_vscode').lazy_load()
require('luasnip.loaders.from_lua').load({ paths = './snippets' })
vim.api.nvim_create_user_command('LuaSnipEdit', function()
require('luasnip.loaders.from_lua').edit_snippet_files()
end, {})
end,
},
-----------------------------------------------------------------------------
{
'ziontee113/SnippetGenie',
event = 'InsertEnter',
dependencies = 'L3MON4D3/LuaSnip',
opts = {
snippets_directory = vim.fn.stdpath('config') .. '/snippets',
},
},
-----------------------------------------------------------------------------
{
'danymat/neogen',
-- stylua: ignore
keys = {
{
'<leader>cc',
function() require('neogen').generate({}) end,
desc = 'Neogen Comment',
},
},
opts = { snippet_engine = 'luasnip' },
},
-----------------------------------------------------------------------------
{
'echasnovski/mini.pairs',
event = 'VeryLazy',
opts = {},
},
-----------------------------------------------------------------------------
{
'echasnovski/mini.surround',
-- stylua: ignore
keys = function(_, keys)
-- Populate the keys based on the user's options
local plugin = require('lazy.core.config').spec.plugins['mini.surround']
local opts = require('lazy.core.plugin').values(plugin, 'opts', false)
local mappings = {
{ opts.mappings.add, desc = 'Add surrounding', mode = { 'n', 'x' } },
{ opts.mappings.delete, desc = 'Delete surrounding' },
{ opts.mappings.find, desc = 'Find right surrounding' },
{ opts.mappings.find_left, desc = 'Find left surrounding' },
{ opts.mappings.highlight, desc = 'Highlight surrounding' },
{ opts.mappings.replace, desc = 'Replace surrounding' },
{ opts.mappings.update_n_lines, desc = 'Update `MiniSurround.config.n_lines`' },
}
mappings = vim.tbl_filter(function(m)
return m[1] and #m[1] > 0
end, mappings)
return vim.list_extend(mappings, keys)
end,
opts = {
mappings = {
add = '<leader>sa', -- Add surrounding in Normal and Visual modes
delete = 'ds', -- Delete surrounding
find = 'gzf', -- Find surrounding (to the right)
find_left = 'gzF', -- Find surrounding (to the left)
highlight = 'gzh', -- Highlight surrounding
replace = 'cs', -- Replace surrounding
update_n_lines = 'gzn', -- Update `n_lines`
},
},
},
-----------------------------------------------------------------------------
{
'echasnovski/mini.comment',
event = 'VeryLazy',
dependencies = { 'JoosepAlviste/nvim-ts-context-commentstring' },
keys = {
{ '<Leader>v', 'gcc', remap = true, silent = true, mode = 'n' },
{ '<Leader>v', 'gc', remap = true, silent = true, mode = 'x' },
},
opts = {
options = {
custom_commentstring = function()
return require('ts_context_commentstring.internal').calculate_commentstring()
or vim.bo.commentstring
end,
},
},
},
-----------------------------------------------------------------------------
{
'echasnovski/mini.trailspace',
event = { 'BufReadPost', 'BufNewFile' },
opts = {},
},
-----------------------------------------------------------------------------
{
'echasnovski/mini.ai',
event = 'VeryLazy',
dependencies = { 'nvim-treesitter/nvim-treesitter-textobjects' },
opts = function()
local ai = require('mini.ai')
return {
n_lines = 500,
-- stylua: ignore
custom_textobjects = {
o = ai.gen_spec.treesitter({
a = { '@block.outer', '@conditional.outer', '@loop.outer' },
i = { '@block.inner', '@conditional.inner', '@loop.inner' },
}, {}),
},
}
end,
},
-----------------------------------------------------------------------------
{
'echasnovski/mini.splitjoin',
keys = {
{
'<leader>sj',
'<cmd>lua MiniSplitjoin.join()<CR>',
mode = { 'n', 'x' },
desc = 'Join arguments',
},
{
'<leader>sk',
'<cmd>lua MiniSplitjoin.split()<CR>',
mode = { 'n', 'x' },
desc = 'Split arguments',
},
},
opts = {
mappings = { toggle = '' },
},
},
-----------------------------------------------------------------------------
{
'AndrewRadev/linediff.vim',
cmd = { 'Linediff', 'LinediffAdd' },
keys = {
{ '<Leader>mdf', ':Linediff<CR>', mode = 'x', desc = 'Line diff' },
{ '<Leader>mda', ':LinediffAdd<CR>', mode = 'x', desc = 'Line diff add' },
{ '<Leader>mds', '<cmd>LinediffShow<CR>', desc = 'Line diff show' },
{ '<Leader>mdr', '<cmd>LinediffReset<CR>', desc = 'Line diff reset' },
},
},
-----------------------------------------------------------------------------
{
'AndrewRadev/dsf.vim',
-- stylua: ignore
keys = {
{ 'dsf', '<Plug>DsfDelete', noremap = true, desc = 'Delete Surrounding Function' },
{ 'csf', '<Plug>DsfChange', noremap = true, desc = 'Change Surrounding Function' },
},
init = function()
vim.g.dsf_no_mappings = 1
end,
},
}

97
lua/plex/plugins/colorscheme.lua
View File

@ -7,99 +7,10 @@ return {
'rafi/theme-loader.nvim', 'rafi/theme-loader.nvim',
lazy = false, lazy = false,
priority = 99, priority = 99,
opts = { initial_colorscheme = 'kanagawa' }, opts = { initial_colorscheme = 'zenbones' },
}, },
{ 'mcchrish/zenbones.nvim', lazy = false,
{ 'rafi/neo-hybrid.vim', priority = 100, lazy = false },
{ 'rafi/awesome-vim-colorschemes', lazy = false },
{ 'AlexvZyl/nordic.nvim' },
{ 'folke/tokyonight.nvim', opts = { style = 'night' } },
{ 'rebelot/kanagawa.nvim' },
{ 'olimorris/onedarkpro.nvim' },
{ 'EdenEast/nightfox.nvim' },
{ 'nyoom-engineering/oxocarbon.nvim' },
{
'catppuccin/nvim',
lazy = true,
name = 'catppuccin',
opts = {
flavour = 'mocha', -- latte, frappe, macchiato, mocha
dim_inactive = { enabled = false },
integrations = {
alpha = true,
cmp = true,
flash = true,
gitsigns = true,
illuminate = true,
indent_blankline = { enabled = true },
lsp_trouble = true,
markdown = true,
mason = true,
mini = true,
native_lsp = {
enabled = true,
virtual_text = {
errors = { 'italic' },
hints = { 'italic' },
warnings = { 'italic' },
information = { 'italic' },
},
underlines = {
errors = { 'undercurl' },
hints = { 'undercurl' },
warnings = { 'undercurl' },
information = { 'undercurl' },
},
inlay_hints = {
background = true,
},
},
navic = { enabled = true },
neogit = true,
neotest = true,
neotree = true,
noice = true,
notify = true,
semantic_tokens = true,
symbols_outline = true,
treesitter_context = true,
telescope = { enabled = true },
treesitter = true,
which_key = true,
},
},
},
{
'rebelot/kanagawa.nvim',
lazy = true,
name = 'kanagawa',
config = function() config = function()
require('kanagawa').setup({ vim.g.zenbones_compat = 1
compile = false, -- enable compiling the colorscheme end}
undercurl = true, -- enable undercurls
commentStyle = { italic = true },
functionStyle = {},
keywordStyle = { italic = true},
statementStyle = { bold = true },
typeStyle = {},
transparent = false, -- do not set background color
dimInactive = false, -- dim inactive window `:h hl-NormalNC`
terminalColors = true, -- define vim.g.terminal_color_{0,17}
colors = { -- add/modify theme and palette colors
palette = {},
theme = { wave = {}, lotus = {}, dragon = {}, all = {} },
},
overrides = function(colors) -- add/modify highlights
return {}
end,
theme = "wave", -- Load "wave" theme when 'background' option is not set
background = { -- map the value of 'background' option to a theme
dark = "wave", -- try "dragon" !
light = "lotus"
},
})
end
},
} }

448
lua/plex/plugins/editor.lua
View File

@ -5,185 +5,6 @@ local is_windows = vim.loop.os_uname().sysname == 'Windows_NT'
return { return {
-----------------------------------------------------------------------------
{ 'nmac427/guess-indent.nvim', lazy = false, priority = 50, config = true },
{ 'tweekmonster/helpful.vim', cmd = 'HelpfulVersion' },
{ 'lambdalisue/suda.vim', lazy = false, event = 'BufRead' },
-----------------------------------------------------------------------------
{
'christoomey/vim-tmux-navigator',
lazy = false,
cond = not is_windows,
-- stylua: ignore
keys = {
{ '<C-h>', '<cmd>TmuxNavigateLeft<CR>', mode = { 'n', 't' }, silent = true, desc = 'Jump to left pane' },
{ '<C-j>', '<cmd>TmuxNavigateDown<CR>', mode = { 'n', 't' }, silent = true, desc = 'Jump to lower pane' },
{ '<C-k>', '<cmd>TmuxNavigateUp<CR>', mode = { 'n', 't' }, silent = true, desc = 'Jump to upper pane' },
{ '<C-l>', '<cmd>TmuxNavigateRight<CR>', mode = { 'n', 't' }, silent = true, desc = 'Jump to right pane' },
},
init = function()
vim.g.tmux_navigator_no_mappings = true
end,
},
-----------------------------------------------------------------------------
{
'olimorris/persisted.nvim',
enabled = true,
event = 'VimEnter',
priority = 1000,
opts = {
autoload = false,
follow_cwd = false,
ignored_dirs = { '/usr', '/opt', '~/.cache', vim.env.TMPDIR or '/tmp' },
},
config = function(_, opts)
if vim.g.in_pager_mode or vim.env.GIT_EXEC_PATH ~= nil then
-- Do not autoload if stdin has been provided, or git commit session.
opts.autoload = false
opts.autosave = false
end
require('persisted').setup(opts)
end,
init = function()
-- Detect if stdin has been provided.
vim.g.in_pager_mode = false
vim.api.nvim_create_autocmd('StdinReadPre', {
group = vim.api.nvim_create_augroup('plex_persisted', {}),
callback = function()
vim.g.in_pager_mode = true
end,
})
-- Close all floats before loading a session. (e.g. Lazy.nvim)
vim.api.nvim_create_autocmd('User', {
group = 'plex_persisted',
pattern = 'PersistedLoadPre',
callback = function()
for _, win in pairs(vim.api.nvim_tabpage_list_wins(0)) do
if vim.api.nvim_win_get_config(win).zindex then
vim.api.nvim_win_close(win, false)
end
end
end,
})
-- Close all plugin owned buffers before saving a session.
vim.api.nvim_create_autocmd('User', {
pattern = 'PersistedSavePre',
group = 'plex_persisted',
callback = function()
-- Detect if window is owned by plugin by checking buftype.
local current_buffer = vim.api.nvim_get_current_buf()
for _, win in ipairs(vim.fn.getwininfo()) do
local buftype = vim.bo[win.bufnr].buftype
if buftype ~= '' and buftype ~= 'help' then
-- Delete plugin owned window buffers.
if win.bufnr == current_buffer then
-- Jump to previous window if current window is not a real file
vim.cmd.wincmd('p')
end
vim.api.nvim_buf_delete(win.bufnr, {})
end
end
end,
})
-- Before switching to a different session using Telescope, save and stop
-- current session to avoid previous session to be overwritten.
vim.api.nvim_create_autocmd('User', {
pattern = 'PersistedTelescopeLoadPre',
group = 'plex_persisted',
callback = function()
require('persisted').save()
require('persisted').stop()
end,
})
-- After switching to a different session using Telescope, start it so it
-- will be auto-saved.
vim.api.nvim_create_autocmd('User', {
pattern = 'PersistedTelescopeLoadPost',
group = 'plex_persisted',
callback = function(session)
require('persisted').start()
print('Started session ' .. session.data.name)
end,
})
end,
},
-----------------------------------------------------------------------------
{
'RRethy/vim-illuminate',
event = { 'BufReadPost', 'BufNewFile' },
opts = {
delay = 200,
under_cursor = false,
modes_allowlist = { 'n', 'no', 'nt' },
filetypes_denylist = {
'DiffviewFileHistory',
'DiffviewFiles',
'SidebarNvim',
'fugitive',
'git',
'minifiles',
'neo-tree',
},
},
keys = {
{ ']]', desc = 'Next Reference' },
{ '[[', desc = 'Prev Reference' },
},
config = function(_, opts)
require('illuminate').configure(opts)
local function map(key, dir, buffer)
vim.keymap.set('n', key, function()
require('illuminate')['goto_' .. dir .. '_reference'](false)
end, {
desc = dir:sub(1, 1):upper() .. dir:sub(2) .. ' Reference',
buffer = buffer,
})
end
map(']]', 'next')
map('[[', 'prev')
-- also set it after loading ftplugins, since a lot overwrite [[ and ]]
vim.api.nvim_create_autocmd('FileType', {
group = vim.api.nvim_create_augroup('plex_illuminate', {}),
callback = function()
local buffer = vim.api.nvim_get_current_buf()
map(']]', 'next', buffer)
map('[[', 'prev', buffer)
end,
})
end,
},
-----------------------------------------------------------------------------
{
'mbbill/undotree',
cmd = 'UndotreeToggle',
keys = {
{ '<Leader>gu', '<cmd>UndotreeToggle<CR>', desc = 'Undo Tree' },
},
},
-----------------------------------------------------------------------------
{
-- NOTE: This is leap for selecting things!
'ggandor/flit.nvim',
enabled = true,
keys = function()
---@type LazyKeys[]
local ret = {}
for _, key in ipairs({ 'f', 'F', 't', 'T' }) do
ret[#ret + 1] = { key, mode = { 'n', 'x', 'o' }, desc = key }
end
return ret
end,
opts = { labeled_modes = 'nx' },
},
----------------------------------------------------------------------------- -----------------------------------------------------------------------------
{ {
'ggandor/leap.nvim', 'ggandor/leap.nvim',
@ -203,45 +24,6 @@ return {
end, end,
}, },
-----------------------------------------------------------------------------
{
'kana/vim-niceblock',
-- stylua: ignore
keys = {
{ 'I', '<Plug>(niceblock-I)', silent = true, mode = 'x', desc = 'Blockwise Insert' },
{ 'gI', '<Plug>(niceblock-gI)', silent = true, mode = 'x', desc = 'Blockwise Insert' },
{ 'A', '<Plug>(niceblock-A)', silent = true, mode = 'x', desc = 'Blockwise Append' },
},
init = function()
vim.g.niceblock_no_default_key_mappings = 0
end,
},
-----------------------------------------------------------------------------
{
'haya14busa/vim-edgemotion',
-- stylua: ignore
keys = {
{ 'gj', '<Plug>(edgemotion-j)', mode = { 'n', 'x' }, desc = 'Move to bottom edge' },
{ 'gk', '<Plug>(edgemotion-k)', mode = { 'n', 'x' }, desc = 'Move to top edge' },
},
},
-----------------------------------------------------------------------------
{
'folke/zen-mode.nvim',
cmd = 'ZenMode',
keys = {
{ '<Leader>zz', '<cmd>ZenMode<CR>', noremap = true, desc = 'Zen Mode' },
},
opts = {
plugins = {
gitsigns = { enabled = true },
tmux = { enabled = vim.env.TMUX ~= nil },
},
},
},
----------------------------------------------------------------------------- -----------------------------------------------------------------------------
-- NOTE: THIS SECTION CONTAINS THE PREFIXES! -- NOTE: THIS SECTION CONTAINS THE PREFIXES!
{ {
@ -296,234 +78,4 @@ return {
}, },
opts = { signs = false }, opts = { signs = false },
}, },
-----------------------------------------------------------------------------
{
'folke/trouble.nvim',
cmd = { 'Trouble', 'TroubleToggle' },
opts = { use_diagnostic_signs = true },
-- stylua: ignore
keys = {
{ '<leader>e', '<cmd>TroubleToggle document_diagnostics<CR>', noremap = true, desc = 'Document Diagnostics' },
{ '<leader>r', '<cmd>TroubleToggle workspace_diagnostics<CR>', noremap = true, desc = 'Workspace Diagnostics' },
{ '<leader>xx', '<cmd>TroubleToggle document_diagnostics<cr>', desc = 'Document Diagnostics (Trouble)' },
{ '<leader>xX', '<cmd>TroubleToggle workspace_diagnostics<cr>', desc = 'Workspace Diagnostics (Trouble)' },
{ '<leader>xQ', '<cmd>TroubleToggle quickfix<cr>', desc = 'Quickfix List (Trouble)' },
{ '<leader>xL', '<cmd>TroubleToggle loclist<cr>', desc = 'Location List (Trouble)' },
{
'[q',
function()
if require('trouble').is_open() then
require('trouble').previous({ skip_groups = true, jump = true })
else
vim.cmd.cprev()
end
end,
desc = 'Previous trouble/quickfix item',
},
{
']q',
function()
if require('trouble').is_open() then
require('trouble').next({ skip_groups = true, jump = true })
else
vim.cmd.cnext()
end
end,
desc = 'Next trouble/quickfix item',
},
},
},
-----------------------------------------------------------------------------
{
'akinsho/toggleterm.nvim',
cmd = 'ToggleTerm',
keys = {
{
'<C-_>',
mode = { 'n', 't' },
silent = true,
function()
local venv = vim.b['virtual_env']
local term = require('toggleterm.terminal').Terminal:new({
env = venv and { VIRTUAL_ENV = venv } or nil,
count = vim.v.count > 0 and vim.v.count or 1,
})
term:toggle()
end,
desc = 'Toggle terminal',
},
},
opts = {
open_mapping = false,
float_opts = {
border = 'curved',
},
},
},
-----------------------------------------------------------------------------
{
'simrat39/symbols-outline.nvim',
cmd = { 'SymbolsOutline', 'SymbolsOutlineOpen' },
keys = {
{ '<Leader>o', '<cmd>SymbolsOutline<CR>', desc = 'Symbols Outline' },
},
opts = {
width = 30,
autofold_depth = 0,
keymaps = {
hover_symbol = 'K',
toggle_preview = 'p',
},
},
init = function()
vim.api.nvim_create_autocmd('FileType', {
group = vim.api.nvim_create_augroup('plex_outline', {}),
pattern = 'Outline',
callback = function()
vim.opt_local.winhighlight = 'CursorLine:WildMenu'
vim.opt_local.signcolumn = 'auto'
end,
})
end,
},
-----------------------------------------------------------------------------
{
's1n7ax/nvim-window-picker',
event = 'VeryLazy',
keys = function(_, keys)
local pick_window = function()
local picked_window_id = require('window-picker').pick_window()
if picked_window_id ~= nil then
vim.api.nvim_set_current_win(picked_window_id)
end
end
local swap_window = function()
local picked_window_id = require('window-picker').pick_window()
if picked_window_id ~= nil then
local current_winnr = vim.api.nvim_get_current_win()
local current_bufnr = vim.api.nvim_get_current_buf()
local other_bufnr = vim.api.nvim_win_get_buf(picked_window_id)
vim.api.nvim_win_set_buf(current_winnr, other_bufnr)
vim.api.nvim_win_set_buf(picked_window_id, current_bufnr)
end
end
local mappings = {
{ '-', pick_window, desc = 'Pick window' },
{ '<leader>wp', pick_window, desc = 'Pick window' },
{ '<leader>ww', swap_window, desc = 'Swap picked window' },
}
return vim.list_extend(mappings, keys)
end,
opts = {
hint = 'floating-big-letter',
show_prompt = false,
filter_rules = {
include_current_win = true,
bo = {
filetype = { 'notify', 'noice' },
buftype = {},
},
},
},
},
-----------------------------------------------------------------------------
{
'rest-nvim/rest.nvim',
ft = 'http',
keys = {
{ '<Leader>mh', '<Plug>RestNvim', desc = 'Execute HTTP request' },
},
opts = { skip_ssl_verification = true },
},
-----------------------------------------------------------------------------
{
'mickael-menu/zk-nvim',
name = 'zk',
ft = 'markdown',
cmd = { 'ZkNew', 'ZkNotes', 'ZkTags', 'ZkMatch' },
-- stylua: ignore
keys = {
{ '<leader>zn', "<Cmd>ZkNew { title = vim.fn.input('Title: ') }<CR>", desc = 'Zk New' },
{ '<leader>zo', "<Cmd>ZkNotes { sort = { 'modified' } }<CR>", desc = 'Zk Notes' },
{ '<leader>zt', '<Cmd>ZkTags<CR>', desc = 'Zk Tags' },
{ '<leader>zf', "<Cmd>ZkNotes { sort = { 'modified' }, match = vim.fn.input('Search: ') }<CR>", desc = 'Zk Search' },
{ '<leader>zf', ":'<,'>ZkMatch<CR>", mode = 'x', desc = 'Zk Match' },
{ '<leader>zb', '<Cmd>ZkBacklinks<CR>', desc = 'Zk Backlinks' },
{ '<leader>zl', '<Cmd>ZkLinks<CR>', desc = 'Zk Links' },
},
opts = { picker = 'telescope' },
},
-----------------------------------------------------------------------------
{
'nvim-pack/nvim-spectre',
-- stylua: ignore
keys = {
{ '<Leader>Sp', function() require('spectre').toggle() end, desc = 'Spectre', },
{ '<Leader>Sp', function() require('spectre').open_visual({ select_word = true }) end, mode = 'x', desc = 'Spectre Word' },
},
opts = {
mapping = {
['toggle_gitignore'] = {
map = 'tg',
cmd = "<cmd>lua require('spectre').change_options('gitignore')<CR>",
desc = 'toggle gitignore',
},
},
find_engine = {
['rg'] = {
cmd = 'rg',
args = {
'--color=never',
'--no-heading',
'--with-filename',
'--line-number',
'--column',
'--ignore',
},
options = {
['gitignore'] = {
value = '--no-ignore',
icon = '[G]',
desc = 'gitignore',
},
},
},
},
default = {
find = {
cmd = 'rg',
options = { 'ignore-case', 'hidden', 'gitignore' },
},
},
},
},
-----------------------------------------------------------------------------
{
'echasnovski/mini.bufremove',
opts = {},
-- stylua: ignore
keys = {
{ '<leader>bd', function() require('mini.bufremove').delete(0, false) end, desc = 'Delete Buffer', },
},
},
-----------------------------------------------------------------------------
{
'mzlogin/vim-markdown-toc',
cmd = { 'GenTocGFM', 'GenTocRedcarpet', 'GenTocGitLab', 'UpdateToc' },
ft = 'markdown',
init = function()
vim.g.vmt_auto_update_on_save = 0
end,
},
} }

18
lua/plex/plugins/extras/coding/autopairs.lua
View File

@ -1,18 +0,0 @@
return {
{
'windwp/nvim-autopairs',
dependencies = 'hrsh7th/nvim-cmp',
config = function()
local autopairs = require('nvim-autopairs')
autopairs.setup()
-- Disable [ rule, it interferes with zk-nvim link completion.
local cond = require('nvim-autopairs.conds')
autopairs.get_rule('['):with_pair(cond.not_filetypes({ 'markdown' }))
-- Insert `(` after function or method item selection.
local cmp_autopairs = require('nvim-autopairs.completion.cmp')
require('cmp').event:on('confirm_done', cmp_autopairs.on_confirm_done())
end,
},
}

26
lua/plex/plugins/extras/coding/cmp-git.lua
View File

@ -1,26 +0,0 @@
return {
{
'hrsh7th/nvim-cmp',
optional = true,
dependencies = { 'petertriho/cmp-git' },
},
{
'petertriho/cmp-git',
opts = {},
config = function()
local cmp = require('cmp')
---@diagnostic disable-next-line: missing-fields
cmp.setup.filetype('gitcommit', {
sources = cmp.config.sources({
{ name = 'git', priority = 50 },
{ name = 'path', priority = 40 },
}, {
{ name = 'buffer', priority = 50 },
{ name = 'emoji', insert = true, priority = 20 },
}),
})
end,
},
}

108
lua/plex/plugins/extras/coding/copilot.lua
View File

@ -1,108 +0,0 @@
-- This is part of LazyVim's code, with my modifications.
-- See: https://github.com/LazyVim/LazyVim/blob/main/lua/lazyvim/plugins/extras/coding/copilot.lua
return {
-----------------------------------------------------------------------------
{
'zbirenbaum/copilot.lua',
enabled = false,
cmd = 'Copilot',
build = ':Copilot auth',
opts = {
suggestion = { enabled = false },
panel = { enabled = false },
filetypes = {
markdown = true,
help = true,
},
},
},
-----------------------------------------------------------------------------
{
'nvim-lualine/lualine.nvim',
optional = true,
event = 'VeryLazy',
opts = function(_, opts)
local get_color = require('plex.lib.color').get_color
local fg = function(...)
return { fg = get_color('fg', ...) }
end
local colors = {
[''] = fg({ 'Comment' }),
['Normal'] = fg({ 'Comment' }),
['Warning'] = fg({ 'DiagnosticError' }),
['InProgress'] = fg({ 'DiagnosticWarn' }),
}
-- Add copilot icon to lualine statusline
table.insert(opts.sections.lualine_x, {
function()
local icon = require('plex.config').icons.kinds.Copilot
local status = require('copilot.api').status.data
return icon .. (status.message or '')
end,
cond = function()
local clients
if vim.lsp.get_clients ~= nil then
clients = vim.lsp.get_clients({ name = 'copilot', bufnr = 0 })
else
---@diagnostic disable-next-line: deprecated
clients = vim.lsp.get_active_clients({
name = 'copilot',
bufnr = 0,
})
end
return #clients > 0
end,
color = function()
if not package.loaded["copilot"] then
return
end
local status = require('copilot.api').status.data
return colors[status.status] or colors['']
end,
})
end,
},
-----------------------------------------------------------------------------
{
'nvim-cmp',
dependencies = {
{
'zbirenbaum/copilot-cmp',
dependencies = 'zbirenbaum/copilot.lua',
opts = {},
config = function(_, opts)
local copilot_cmp = require('copilot_cmp')
copilot_cmp.setup(opts)
-- attach cmp source whenever copilot attaches
-- fixes lazy-loading issues with the copilot cmp source
---@param client lsp.Client
require('plex.lib.utils').on_attach(function(client)
if client.name == 'copilot' then
copilot_cmp._on_insert_enter({})
end
end)
end,
},
},
---@param opts cmp.ConfigSchema|{sources: table[]}
opts = function(_, opts)
-- Add copilot nvim-cmp source.
table.insert(opts.sources, 1, {
name = 'copilot',
group_index = 2,
priority = 60,
})
opts.sorting = opts.sorting or require('cmp.config.default')().sorting
table.insert(
opts.sorting.comparators,
1,
require('copilot_cmp.comparators').prioritize
)
end,
},
}

20
lua/plex/plugins/extras/coding/editorconfig.lua
View File

@ -1,20 +0,0 @@
return {
{
'sgur/vim-editorconfig',
lazy = false,
init = function()
vim.g.editorconfig_verbose = 1
vim.g.editorconfig_blacklist = {
filetype = {
'git.*',
'fugitive',
'help',
'lsp-.*',
'any-jump',
'gina-.*',
},
pattern = { '\\.un~$' },
}
end,
},
}

31
lua/plex/plugins/extras/coding/emmet.lua
View File

@ -1,31 +0,0 @@
return {
{
'mattn/emmet-vim',
ft = { 'html', 'css', 'vue', 'javascript', 'javascriptreact', 'svelte' },
init = function()
vim.g.user_emmet_mode = 'i'
vim.g.user_emmet_install_global = 0
vim.g.user_emmet_install_command = 0
vim.g.user_emmet_complete_tag = 0
end,
config = function()
vim.api.nvim_create_autocmd('FileType', {
group = vim.api.nvim_create_augroup('plex_emmet', {}),
pattern = {
'css',
'html',
'javascript',
'javascriptreact',
'svelte',
'vue',
},
callback = function()
vim.cmd([[
EmmetInstall
imap <silent><buffer> <C-y> <Plug>(emmet-expand-abbr)
]])
end,
})
end,
},
}

19
lua/plex/plugins/extras/coding/sandwich.lua
View File

@ -1,19 +0,0 @@
return {
{
'machakann/vim-sandwich',
-- stylua: ignore
keys = {
-- See https://github.com/machakann/vim-sandwich/blob/master/macros/sandwich/keymap/surround.vim
{ 'ds', '<Plug>(operator-sandwich-delete)<Plug>(operator-sandwich-release-count)<Plug>(textobj-sandwich-query-a)', silent = true },
{ 'dss', '<Plug>(operator-sandwich-delete)<Plug>(operator-sandwich-release-count)<Plug>(textobj-sandwich-auto-a)', silent = true },
{ 'cs', '<Plug>(operator-sandwich-replace)<Plug>(operator-sandwich-release-count)<Plug>(textobj-sandwich-query-a)', silent = true },
{ 'css', '<Plug>(operator-sandwich-replace)<Plug>(operator-sandwich-release-count)<Plug>(textobj-sandwich-auto-a)', silent = true },
{ 'sa', '<Plug>(operator-sandwich-add)', silent = true, mode = { 'n', 'x', 'o' }},
{ 'ir', '<Plug>(textobj-sandwich-auto-i)', silent = true, mode = { 'x', 'o' }},
{ 'ab', '<Plug>(textobj-sandwich-auto-a)', silent = true, mode = { 'x', 'o' }},
},
init = function()
vim.g.sandwich_no_default_key_mappings = 1
end,
},
}

22
lua/plex/plugins/extras/diagnostics/proselint.lua
View File

@ -1,22 +0,0 @@
return {
{
'williamboman/mason.nvim',
opts = function(_, opts)
table.insert(opts.ensure_installed, 'proselint')
end,
},
{
'jose-elias-alvarez/null-ls.nvim',
optional = true,
opts = function(_, opts)
local nls = require('null-ls')
local source = nls.builtins.diagnostics.proselint.with({
diagnostics_postprocess = function(diagnostic)
diagnostic.severity = vim.diagnostic.severity.HINT
end,
})
table.insert(opts.sources, source)
end,
},
}

22
lua/plex/plugins/extras/diagnostics/write-good.lua
View File

@ -1,22 +0,0 @@
return {
{
'williamboman/mason.nvim',
opts = function(_, opts)
table.insert(opts.ensure_installed, 'write-good')
end,
},
{
'jose-elias-alvarez/null-ls.nvim',
optional = true,
opts = function(_, opts)
local nls = require('null-ls')
local source = nls.builtins.diagnostics.write_good.with({
diagnostics_postprocess = function(diagnostic)
diagnostic.severity = vim.diagnostic.severity.HINT
end,
})
table.insert(opts.sources, source)
end,
},
}

22
lua/plex/plugins/extras/editor/anyjump.lua
View File

@ -1,22 +0,0 @@
return {
{
'pechorin/any-jump.vim',
cmd = { 'AnyJump', 'AnyJumpVisual' },
keys = {
{ '<leader>ii', '<cmd>AnyJump<CR>', desc = 'Any Jump' },
{ '<leader>ii', '<cmd>AnyJumpVisual<CR>', mode = 'x', desc = 'Any Jump' },
{ '<leader>ib', '<cmd>AnyJumpBack<CR>', desc = 'Any Jump Back' },
{ '<leader>il', '<cmd>AnyJumpLastResults<CR>', desc = 'Any Jump Resume' },
},
init = function()
vim.g.any_jump_disable_default_keybindings = 1
vim.api.nvim_create_autocmd('FileType', {
group = vim.api.nvim_create_augroup('plex_any-jump', {}),
pattern = 'any-jump',
callback = function()
vim.opt.cursorline = true
end,
})
end,
},
}

11
lua/plex/plugins/extras/editor/flybuf.lua
View File

@ -1,11 +0,0 @@
return {
{
'glepnir/flybuf.nvim',
cmd = 'FlyBuf',
keys = {
-- stylua: ignore
{ '<Leader><Tab>', function() require('flybuf').toggle() end, desc = 'Flybuf' },
},
opts = {},
},
}

14
lua/plex/plugins/extras/editor/sidebar.lua
View File

@ -1,14 +0,0 @@
return {
{
'sidebar-nvim/sidebar.nvim',
main = 'sidebar-nvim',
cmd = { 'SidebarNvimToggle', 'SidebarNvimOpen' },
opts = {
open = true,
bindings = {
-- stylua: ignore
['q'] = function() require('sidebar-nvim').close() end,
},
},
},
}

8
lua/plex/plugins/extras/editor/table-mode.lua
View File

@ -1,8 +0,0 @@
return {
{
"dhruvasagar/vim-table-mode",
lazy = false,
-- <Leader>tm is automatically set for toggle
-- see <Leader>t menu
},
}

112
lua/plex/plugins/extras/editor/ufo.lua
View File

@ -1,112 +0,0 @@
return {
{
'neovim/nvim-lspconfig',
opts = {
capabilities = {
textDocument = {
foldingRange = {
dynamicRegistration = false,
lineFoldingOnly = true,
},
},
},
},
},
{
'kevinhwang91/nvim-ufo',
event = { 'BufReadPost', 'BufNewFile' },
-- stylua: ignore
keys = {
{ 'zR', function() require('ufo').openAllFolds() end },
{ 'zM', function() require('ufo').closeAllFolds() end },
-- { 'zr', function() require('ufo').openFoldsExceptKinds() end },
-- { 'zm', function() require('ufo').closeFoldsWith() end },
},
dependencies = {
'kevinhwang91/promise-async',
'nvim-treesitter/nvim-treesitter',
'neovim/nvim-lspconfig',
},
opts = function()
-- lsp->treesitter->indent
---@param bufnr number
---@return table
local function customizeSelector(bufnr)
local function handleFallbackException(err, providerName)
if type(err) == 'string' and err:match('UfoFallbackException') then
return require('ufo').getFolds(bufnr, providerName)
else
return require('promise').reject(err)
end
end
return require('ufo')
.getFolds(bufnr, 'lsp')
:catch(function(err)
return handleFallbackException(err, 'treesitter')
end)
:catch(function(err)
return handleFallbackException(err, 'indent')
end)
end
local ft_providers = {
vim = 'indent',
python = { 'indent' },
git = '',
help = '',
qf = '',
fugitive = '',
fugitiveblame = '',
['neo-tree'] = '',
}
return {
open_fold_hl_timeout = 0,
preview = {
win_config = {
border = { '', '─', '', '', '', '─', '', '' },
winhighlight = 'Normal:Folded',
winblend = 10,
},
mappings = {
scrollU = '<C-u>',
scrollD = '<C-d>',
jumpTop = '[',
jumpBot = ']',
},
},
-- Select the fold provider.
provider_selector = function(_, filetype, _)
return ft_providers[filetype] or customizeSelector
end,
-- Display text for folded lines.
---@param text table
---@param lnum integer
---@param endLnum integer
---@param width integer
---@return table
fold_virt_text_handler = function(text, lnum, endLnum, width)
local suffix = ' 󰇘 '
local lines = (' 󰁂 %d '):format(endLnum - lnum)
local cur_width = 0
for _, section in ipairs(text) do
cur_width = cur_width + vim.fn.strdisplaywidth(section[1])
end
suffix = suffix
.. (' '):rep(width - cur_width - vim.fn.strdisplaywidth(lines) - 3)
table.insert(text, { suffix, 'UfoFoldedEllipsis' })
table.insert(text, { lines, 'Folded' })
return text
end,
}
end,
},
}

13
lua/plex/plugins/extras/editor/vim-eunuch.lua
View File

@ -1,13 +0,0 @@
return {
{
-- enables UNIX specific stuff in vim,
-- specifically:
-- :SudoWrite
-- :SudoRead
-- :Chmod
-- and also some more, but those are easy done with shell
"tpope/vim-eunuch",
enabled = false,
lazy=false,
}
}

36
lua/plex/plugins/extras/formatting/prettier.lua
View File

@ -1,36 +0,0 @@
-- This is part of LazyVim's code, with my modifications.
-- See: https://github.com/LazyVim/LazyVim/blob/main/lua/lazyvim/plugins/extras/formatting/prettier.lua
return {
{
'williamboman/mason.nvim',
opts = function(_, opts)
if type(opts.ensure_installed) == 'table' then
table.insert(opts.ensure_installed, 'prettierd')
end
end,
},
{
'mhartington/formatter.nvim',
optional = true,
opts = function(_, opts)
opts = opts or {}
local filetypes = {
-- FIXME:add more filetypes
json = { require('formatter.defaults.prettierd') },
}
opts.filetype = vim.tbl_extend('keep', opts.filetype or {}, filetypes)
end,
},
{
'jose-elias-alvarez/null-ls.nvim',
optional = true,
opts = function(_, opts)
local nls = require('null-ls')
table.insert(opts.sources, nls.builtins.formatting.prettierd)
end,
},
}

31
lua/plex/plugins/extras/git/fugitive.lua
View File

@ -1,31 +0,0 @@
return {
-----------------------------------------------------------------------------
{
'tpope/vim-fugitive',
cmd = { 'G', 'Git', 'Gfetch', 'Gpush', 'Gclog', 'Gdiffsplit' },
keys = {
{ '<leader>gd', '<cmd>Gdiffsplit<CR>', desc = 'Git diff' },
{ '<leader>gb', '<cmd>Git blame<CR>', desc = 'Git blame' },
},
config = function()
vim.api.nvim_create_autocmd('FileType', {
group = vim.api.nvim_create_augroup('rafi_fugitive', {}),
pattern = 'fugitiveblame',
callback = function()
vim.schedule(function()
vim.cmd.normal('A')
end)
end,
})
end,
},
-----------------------------------------------------------------------------
{
'junegunn/gv.vim',
dependencies = { 'tpope/vim-fugitive' },
cmd = 'GV',
},
}

72
lua/plex/plugins/extras/lang/ansible.lua
View File

@ -1,72 +0,0 @@
-- rafi.plugins.extras.lang.ansible
--
return {
{
'nvim-treesitter/nvim-treesitter',
dependencies = {
'pearofducks/ansible-vim',
ft = { 'ansible', 'ansible_hosts', 'jinja2' },
},
opts = function(_, opts)
if type(opts.ensure_installed) == 'table' then
vim.list_extend(opts.ensure_installed, { 'yaml' })
end
vim.g.ansible_extra_keywords_highlight = 1
vim.g.ansible_template_syntaxes = {
['*.json.j2'] = 'json',
['*.(ba)?sh.j2'] = 'sh',
['*.ya?ml.j2'] = 'yaml',
['*.xml.j2'] = 'xml',
['*.conf.j2'] = 'conf',
['*.ini.j2'] = 'ini',
}
-- Setup filetype settings
vim.api.nvim_create_autocmd('FileType', {
group = vim.api.nvim_create_augroup('plex_ftplugin_ansible', {}),
pattern = 'ansible',
callback = function()
-- Add '.' to iskeyword for ansible modules, e.g. ansible.builtin.copy
vim.opt_local.iskeyword:append('.')
vim.b.undo_ftplugin = (vim.b.undo_ftplugin or '')
.. (vim.b.undo_ftplugin ~= nil and ' | ' or '')
.. 'setlocal iskeyword<'
if vim.fn.executable('ansible-doc') then
vim.b.undo_ftplugin = vim.b.undo_ftplugin
.. '| sil! nunmap <buffer> gK'
vim.keymap.set('n', 'gK', function()
-- Open ansible-doc in a vertical split with word under cursor.
vim.cmd([[
vertical split
| execute('terminal PAGER=cat ansible-doc ' .. shellescape(expand('<cword>')))
| setf man
| wincmd p
]])
end, { buffer = 0 })
end
end,
})
end,
},
{
'neovim/nvim-lspconfig',
opts = {
servers = {
ansiblels = {},
},
},
},
{
'mason.nvim',
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(opts.ensure_installed, { 'ansible-lint' })
end,
},
}

50
lua/plex/plugins/extras/lang/docker.lua
View File

@ -1,50 +0,0 @@
-- This is part of LazyVim's code, with my modifications.
-- See: https://github.com/LazyVim/LazyVim/blob/main/lua/lazyvim/plugins/extras/lang/docker.lua
return {
{
'nvim-treesitter/nvim-treesitter',
opts = function(_, opts)
if type(opts.ensure_installed) == 'table' then
vim.list_extend(opts.ensure_installed, { 'dockerfile' })
end
end,
},
{
'neovim/nvim-lspconfig',
opts = {
servers = {
dockerls = {},
-- docker_compose_language_service = {},
},
},
},
{
'mason.nvim',
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(opts.ensure_installed, { 'hadolint' })
end,
},
{
'jose-elias-alvarez/null-ls.nvim',
optional = true,
opts = function(_, opts)
local nls = require('null-ls')
opts.sources = opts.sources or {}
vim.list_extend(opts.sources, {
nls.builtins.diagnostics.hadolint,
})
end,
dependencies = {
'mason.nvim',
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(opts.ensure_installed, { 'hadolint' })
end,
},
},
}

199
lua/plex/plugins/extras/lang/go.lua
View File

@ -1,199 +0,0 @@
-- This is part of LazyVim's code, with my modifications.
-- See: https://github.com/LazyVim/LazyVim/blob/main/lua/lazyvim/plugins/extras/lang/go.lua
return {
{
'nvim-treesitter/nvim-treesitter',
opts = function(_, opts)
if type(opts.ensure_installed) == 'table' then
vim.list_extend(opts.ensure_installed, {
'go',
'gomod',
'gosum',
'gowork',
})
end
-- Convert a JSON string to a Go struct.
vim.api.nvim_buf_create_user_command(
0,
'JsonToStruct',
---@param args table
function(args)
local range = args.line1 .. ',' .. args.line2
local fname = vim.api.nvim_buf_get_name(0)
local cmd = { '!json-to-struct' }
table.insert(cmd, '-name ' .. vim.fn.fnamemodify(fname, ':t:r'))
table.insert(cmd, '-pkg ' .. vim.fn.fnamemodify(fname, ':h:t:r'))
vim.cmd(range .. ' ' .. table.concat(cmd, ' '))
end,
{ bar = true, nargs = 0, range = true }
)
end,
},
{
'neovim/nvim-lspconfig',
opts = {
servers = {
-- gopls = {
-- settings = {
-- -- https://github.com/golang/tools/blob/master/gopls/doc/settings.md
-- gopls = {
-- gofumpt = true,
-- usePlaceholders = true,
-- completeUnimported = true,
-- staticcheck = true,
-- directoryFilters = {
-- '-.git',
-- '-.vscode',
-- '-.idea',
-- '-.vscode-test',
-- '-node_modules',
-- },
-- semanticTokens = true,
-- codelenses = {
-- gc_details = false,
-- generate = true,
-- regenerate_cgo = true,
-- run_govulncheck = true,
-- test = true,
-- tidy = true,
-- upgrade_dependency = true,
-- vendor = true,
-- },
-- hints = {
-- assignVariableTypes = true,
-- compositeLiteralFields = true,
-- compositeLiteralTypes = true,
-- constantValues = true,
-- functionTypeParameters = true,
-- parameterNames = true,
-- rangeVariableTypes = true,
-- },
-- -- https://github.com/golang/tools/blob/master/gopls/doc/analyzers.md
-- analyses = {
-- fieldalignment = true,
-- nilness = true,
-- unusedparams = true,
-- unusedwrite = true,
-- useany = true,
-- -- fillreturns = true,
-- -- nonewvars = true,
-- -- shadow = true,
-- -- undeclaredname = true,
-- -- unusedvariable = true,
-- -- ST1000 = false,
-- -- ST1005 = false,
-- },
-- },
-- },
-- },
},
setup = {
gopls = function(_, _)
-- workaround for gopls not supporting semanticTokensProvider
-- https://github.com/golang/go/issues/54531#issuecomment-1464982242
require('plex.lib.utils').on_attach(function(client, _)
if client.name == 'gopls' then
if not client.server_capabilities.semanticTokensProvider then
local semantic =
client.config.capabilities.textDocument.semanticTokens
if semantic ~= nil then
client.server_capabilities.semanticTokensProvider = {
full = true,
legend = {
tokenTypes = semantic.tokenTypes,
tokenModifiers = semantic.tokenModifiers,
},
range = true,
}
end
end
end
end)
-- end workaround
end,
},
},
},
{
'mason.nvim',
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(opts.ensure_installed, {
'gofumpt',
'goimports-reviser',
'gomodifytags',
'impl',
'json-to-struct',
})
end,
},
{
'mhartington/formatter.nvim',
optional = true,
opts = function(_, opts)
opts = opts or {}
local filetypes = {
go = {
require('formatter.filetypes.go').gofumpt,
},
}
opts.filetype = vim.tbl_extend('keep', opts.filetype or {}, filetypes)
end,
},
{
'jose-elias-alvarez/null-ls.nvim',
optional = true,
opts = function(_, opts)
local nls = require('null-ls')
local sources = {
nls.builtins.code_actions.gomodifytags,
nls.builtins.code_actions.impl,
nls.builtins.formatting.gofumpt,
-- nls.builtins.formatting.goimports_reviser,
}
opts.sources = opts.sources or {}
for _, source in ipairs(sources) do
table.insert(opts.sources, source)
end
end,
},
{
'mfussenegger/nvim-dap',
optional = true,
dependencies = {
{
'mason.nvim',
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(opts.ensure_installed, { 'delve' })
end,
},
{
'leoluz/nvim-dap-go',
config = true,
},
},
},
{
'nvim-neotest/neotest',
optional = true,
dependencies = { 'nvim-neotest/neotest-go' },
opts = {
adapters = {
['neotest-go'] = {
-- Here we can set options for neotest-go, e.g.
-- args = { '-tags=integration' }
},
},
},
},
}

24
lua/plex/plugins/extras/lang/helm.lua
View File

@ -1,24 +0,0 @@
-- rafi.plugins.extras.lang.helm
--
return {
{ 'towolf/vim-helm', ft = 'helm' },
{
'nvim-treesitter/nvim-treesitter',
opts = function(_, opts)
if type(opts.ensure_installed) == 'table' then
vim.list_extend(opts.ensure_installed, { 'yaml' })
end
end,
},
{
'mason.nvim',
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
vim.list_extend(opts.ensure_installed, { 'helm-ls' })
end,
},
}

40
lua/plex/plugins/extras/lang/json.lua
View File

@ -1,40 +0,0 @@
-- This is part of LazyVim's code, with my modifications.
-- See: https://github.com/LazyVim/LazyVim/blob/main/lua/lazyvim/plugins/extras/lang/json.lua
return {
{
'nvim-treesitter/nvim-treesitter',
opts = function(_, opts)
if type(opts.ensure_installed) == 'table' then
vim.list_extend(opts.ensure_installed, { 'json', 'json5', 'jsonc' })
end
end,
},
{
'neovim/nvim-lspconfig',
dependencies = { 'b0o/SchemaStore.nvim', version = false },
opts = {
servers = {
jsonls = {
-- lazy-load schemastore when needed
on_new_config = function(new_config)
new_config.settings.json.schemas = new_config.settings.json.schemas
or {}
vim.list_extend(
new_config.settings.json.schemas,
require('schemastore').json.schemas()
)
end,
settings = {
json = {
format = { enable = true },
validate = { enable = true },
},
},
},
},
},
},
}

72
lua/plex/plugins/extras/lang/python.lua
View File

@ -1,72 +0,0 @@
-- rafi.plugins.extras.lang.python
--
-- This is part of LazyVim's code, with my modifications.
-- See: https://github.com/LazyVim/LazyVim/blob/main/lua/lazyvim/plugins/extras/lang/python.lua
return {
{
'nvim-treesitter/nvim-treesitter',
opts = function(_, opts)
if type(opts.ensure_installed) == 'table' then
vim.list_extend(
opts.ensure_installed,
{ 'ninja', 'python', 'requirements', 'rst', 'toml' }
)
end
end,
},
{
'neovim/nvim-lspconfig',
dependencies = 'rafi/neoconf-venom.nvim',
opts = {
servers = {
pyright = {},
},
},
},
{
'rafi/neoconf-venom.nvim',
main = 'venom',
opts = {},
-- stylua: ignore
keys = {
{ '<leader>cv', '<cmd>Telescope venom virtualenvs<cr>', desc = 'Select VirtualEnv' },
},
},
{
'nvim-neotest/neotest',
optional = true,
dependencies = { 'nvim-neotest/neotest-python' },
opts = {
adapters = {
['neotest-python'] = {
-- Here you can specify the settings for the adapter, i.e.
-- runner = "pytest",
-- python = '.venv/bin/python',
},
},
},
},
{
'mfussenegger/nvim-dap',
optional = true,
dependencies = {
'mfussenegger/nvim-dap-python',
-- stylua: ignore
keys = {
{ '<leader>dPt', function() require('dap-python').test_method() end, desc = 'Debug Method' },
{ '<leader>dPc', function() require('dap-python').test_class() end, desc = 'Debug Class' },
},
config = function()
local path =
require('mason-registry').get_package('debugpy'):get_install_path()
require('dap-python').setup(path .. '/venv/bin/python')
end,
},
},
}

38
lua/plex/plugins/extras/lang/terraform.lua
View File

@ -1,38 +0,0 @@
-- This is part of LazyVim's code, with my modifications.
-- See: https://github.com/LazyVim/LazyVim/blob/main/lua/lazyvim/plugins/extras/lang/terraform.lua
return {
{
'nvim-treesitter/nvim-treesitter',
opts = function(_, opts)
if type(opts.ensure_installed) == 'table' then
vim.list_extend(opts.ensure_installed, {
'terraform',
'hcl',
})
end
end,
},
{
'neovim/nvim-lspconfig',
opts = {
servers = {
terraformls = {},
},
},
},
{
'jose-elias-alvarez/null-ls.nvim',
optional = true,
opts = function(_, opts)
if type(opts.sources) == 'table' then
local builtins = require('null-ls.builtins')
table.insert(opts.sources, builtins.formatting.terraform_fmt)
table.insert(opts.sources, builtins.diagnostics.terraform_validate)
end
end,
},
}

125
lua/plex/plugins/extras/lang/typescript.lua
View File

@ -1,125 +0,0 @@
-- This is part of LazyVim's code, with my modifications.
-- See: https://github.com/LazyVim/LazyVim/blob/main/lua/lazyvim/plugins/extras/lang/typescript.lua
return {
-- add typescript to treesitter
{
'nvim-treesitter/nvim-treesitter',
opts = function(_, opts)
if type(opts.ensure_installed) == 'table' then
vim.list_extend(opts.ensure_installed, { 'typescript', 'tsx' })
end
end,
},
-- correctly setup lspconfig
{
'neovim/nvim-lspconfig',
dependencies = { 'jose-elias-alvarez/typescript.nvim' },
opts = {
-- make sure mason installs the server
servers = {
---@type lspconfig.options.tsserver
tsserver = {
-- stylua: ignore
keys = {
{ '<leader>co', '<cmd>TypescriptOrganizeImports<CR>', desc = 'Organize Imports' },
{ '<leader>cR', '<cmd>TypescriptRenameFile<CR>', desc = 'Rename File' },
},
settings = {
---@diagnostic disable: missing-fields
typescript = {
format = {
indentSize = vim.o.shiftwidth,
convertTabsToSpaces = vim.o.expandtab,
tabSize = vim.o.tabstop,
},
},
javascript = {
format = {
indentSize = vim.o.shiftwidth,
convertTabsToSpaces = vim.o.expandtab,
tabSize = vim.o.tabstop,
},
},
completions = {
completeFunctionCalls = true,
},
},
},
},
setup = {
tsserver = function(_, opts)
require('typescript').setup({ server = opts })
return true
end,
},
},
},
{
'jose-elias-alvarez/null-ls.nvim',
optional = true,
opts = function(_, opts)
table.insert(
opts.sources,
require('typescript.extensions.null-ls.code-actions')
)
end,
},
{
'mfussenegger/nvim-dap',
optional = true,
dependencies = {
{
'williamboman/mason.nvim',
opts = function(_, opts)
opts.ensure_installed = opts.ensure_installed or {}
table.insert(opts.ensure_installed, 'js-debug-adapter')
end,
},
},
opts = function()
local dap = require('dap')
if not dap.adapters['pwa-node'] then
require('dap').adapters['pwa-node'] = {
type = 'server',
host = 'localhost',
port = '${port}',
executable = {
command = 'node',
-- 💀 Make sure to update this path to point to your installation
args = {
require('mason-registry')
.get_package('js-debug-adapter')
:get_install_path() .. '/js-debug/src/dapDebugServer.js',
'${port}',
},
},
}
end
for _, language in ipairs({ 'typescript', 'javascript' }) do
if not dap.configurations[language] then
dap.configurations[language] = {
{
type = 'pwa-node',
request = 'launch',
name = 'Launch file',
program = '${file}',
cwd = '${workspaceFolder}',
},
{
type = 'pwa-node',
request = 'attach',
name = 'Attach',
processId = require('dap.utils').pick_process,
cwd = '${workspaceFolder}',
},
}
end
end
end,
},
}

63
lua/plex/plugins/extras/lang/yaml.lua
View File

@ -1,63 +0,0 @@
-- This is part of LazyVim's code, with my modifications.
-- See: https://github.com/LazyVim/LazyVim/blob/main/lua/lazyvim/plugins/extras/lang/yaml.lua
return {
{
'nvim-treesitter/nvim-treesitter',
opts = function(_, opts)
if type(opts.ensure_installed) == 'table' then
vim.list_extend(opts.ensure_installed, { 'yaml' })
end
end,
},
{
'neovim/nvim-lspconfig',
dependencies = { 'b0o/SchemaStore.nvim', version = false },
opts = {
servers = {
yamlls = {
-- Have to add this for yamlls to understand that we support line folding
capabilities = {
textDocument = {
foldingRange = {
dynamicRegistration = false,
lineFoldingOnly = true,
},
},
},
-- Lazy-load schemastore when needed
on_new_config = function(new_config)
new_config.settings.yaml.schemas = vim.tbl_extend(
'force',
require('schemastore').yaml.schemas(),
new_config.settings.yaml.schemas or {}
)
end,
settings = {
redhat = { telemetry = { enabled = false } },
yaml = {
completion = true,
hover = true,
validate = true,
format = {
enable = true,
},
schemaStore = {
-- Must disable built-in schemaStore support to use
-- schemas from SchemaStore.nvim plugin
enable = false,
-- Avoid TypeError: Cannot read properties of undefined (reading 'length')
url = '',
},
schemas = {
kubernetes = { 'k8s**.yaml', 'kube*/*.yaml' },
},
},
},
},
},
},
},
}

50
lua/plex/plugins/extras/linting/ruff.lua
View File

@ -1,50 +0,0 @@
return {
{
'neovim/nvim-lspconfig',
opts = {
servers = {
ruff_lsp = {},
},
setup = {
ruff_lsp = function(_, opts)
local root_files = {
'.python-version',
'pyproject.toml',
'ruff.toml',
}
local util = require('lspconfig.util')
opts.root_dir = util.root_pattern(unpack(root_files))
or util.find_git_ancestor()
require('plex.lib.utils').on_attach(function(client, _)
if client.name == 'ruff_lsp' then
client.server_capabilities.hoverProvider = false
end
end)
end,
},
},
},
{
'williamboman/mason.nvim',
opts = function(_, opts)
vim.list_extend(opts.ensure_installed, {
'ruff',
'ruff-lsp',
})
end,
},
{
'jose-elias-alvarez/null-ls.nvim',
optional = true,
opts = function(_, opts)
if type(opts.sources) == 'table' then
local nls = require('null-ls')
table.insert(opts.sources, nls.builtins.formatting.ruff)
end
end,
},
}

33
lua/plex/plugins/extras/lsp/gtd.lua
View File

@ -1,33 +0,0 @@
return {
{
'hrsh7th/nvim-gtd',
event = { 'BufReadPre', 'BufNewFile' },
dependencies = 'neovim/nvim-lspconfig',
-- stylua: ignore
keys = {
{
'gf',
function() require('gtd').exec({ command = 'split' }) end,
desc = 'Go to definition or file',
},
},
---@type gtd.kit.App.Config.Schema
opts = {
sources = {
{ name = 'findup' },
{
name = 'walk',
root_markers = {
'.git',
'.neoconf.json',
'Makefile',
'package.json',
'tsconfig.json',
},
ignore_patterns = { '/node_modules', '/.git' },
},
{ name = 'lsp' },
},
},
},
}

22
lua/plex/plugins/extras/lsp/inlayhints.lua
View File

@ -1,22 +0,0 @@
return {
-- Not needed anymore with nvim-0.10.0
{
'lvimuser/lsp-inlayhints.nvim',
branch = 'anticonceal',
event = 'LspAttach',
opts = {},
config = function(_, opts)
require('lsp-inlayhints').setup(opts)
vim.api.nvim_create_autocmd('LspAttach', {
group = vim.api.nvim_create_augroup('LspAttach_inlayhints', {}),
callback = function(args)
if not (args.data and args.data.client_id) then
return
end
local client = vim.lsp.get_client_by_id(args.data.client_id)
require('lsp-inlayhints').on_attach(client, args.buf)
end,
})
end,
},
}

20
lua/plex/plugins/extras/lsp/lightbulb.lua
View File

@ -1,20 +0,0 @@
return {
{
'kosayoda/nvim-lightbulb',
event = { 'BufReadPre', 'BufNewFile' },
opts = {
ignore = {
clients = { 'null-ls' },
},
},
config = function(_, opts)
require('nvim-lightbulb').setup(opts)
vim.api.nvim_create_autocmd('CursorHold', {
group = vim.api.nvim_create_augroup('rafi_lightbulb', {}),
callback = function()
require('nvim-lightbulb').update_lightbulb()
end,
})
end,
},
}

62
lua/plex/plugins/extras/lsp/null-ls.lua
View File

@ -1,62 +0,0 @@
return {
{
'jose-elias-alvarez/null-ls.nvim',
event = { 'BufReadPre', 'BufNewFile' },
dependencies = { 'williamboman/mason.nvim' },
opts = function(_, opts)
-- https://github.com/jose-elias-alvarez/null-ls.nvim/blob/main/doc/BUILTINS.md
local builtins = require('null-ls').builtins
local sources = {
builtins.formatting.stylua,
builtins.formatting.shfmt,
}
for _, source in ipairs(sources) do
table.insert(opts.sources, source)
end
opts.fallback_severity = vim.diagnostic.severity.INFO
opts.should_attach = function(bufnr)
return not vim.api.nvim_buf_get_name(bufnr):match('^[a-z]+://')
end
opts.root_dir = require('null-ls.utils').root_pattern(
'.git',
'_darcs',
'.hg',
'.bzr',
'.svn',
'.null-ls-root',
'.neoconf.json',
'.python-version',
'Makefile'
)
end,
},
-- You can add your own sources. Here's an example:
-- {
-- 'jose-elias-alvarez/null-ls.nvim',
-- optional = true,
-- opts = function(_, opts)
-- local builtins = require('null-ls.builtins')
-- local sources = {
-- builtins.formatting.black,
-- builtins.formatting.fixjson,
-- builtins.formatting.golines,
-- builtins.formatting.markdownlint,
-- builtins.formatting.shellharden,
-- builtins.formatting.sql_formatter,
-- builtins.formatting.taplo,
-- builtins.diagnostics.markdownlint,
-- builtins.diagnostics.mypy,
-- builtins.diagnostics.vint,
-- builtins.diagnostics.yamllint,
-- builtins.code_actions.shellcheck,
-- }
-- opts.sources = opts.sources or {}
-- for _, source in ipairs(sources) do
-- table.insert(opts.sources, source)
-- end
-- end,
-- },
}

33
lua/plex/plugins/extras/lsp/yaml-companion.lua
View File

@ -1,33 +0,0 @@
return {
{
'neovim/nvim-lspconfig',
opts = {
setup = {
yamlls = function(_, _)
local yamlls_opts = require('yaml-companion').setup(
require('plex.lib.utils').opts('yaml-companion.nvim')
)
require('lspconfig')['yamlls'].setup(yamlls_opts)
return true
end,
},
},
},
{
'someone-stole-my-name/yaml-companion.nvim',
dependencies = {
'neovim/nvim-lspconfig',
'nvim-telescope/telescope.nvim',
},
keys = {
-- stylua: ignore
{ '<localleader>y', '<cmd>Telescope yaml_schema<CR>', desc = 'YAML Schema' },
},
opts = {},
config = function(_, _)
require('telescope').load_extension('yaml_schema')
end,
},
}

26
lua/plex/plugins/extras/org/neorg.lua
View File

@ -1,26 +0,0 @@
return {
{
"nvim-neorg/neorg",
lazy = false,
build = ":Neorg sync-parsers",
dependencies = { "nvim-lua/plenary.nvim" },
config = function()
require("neorg").setup {
load = {
["core.defaults"] = {}, -- Loads default behaviour
["core.concealer"] = {}, -- Adds pretty icons to your documents
["core.dirman"] = { -- Manages Neorg workspaces
config = {
workspaces = {
-- FIXME: This shouldn't be in the Versioncontrol. Make this
-- into a local extension of the plugin.
main = "~/Nextcloud/Neorg",
notes = "~/Nextcloud/Notes",
},
},
},
},
}
end,
},
}

45
lua/plex/plugins/extras/org/vimwiki.lua
View File

@ -1,45 +0,0 @@
return {
{
'vimwiki/vimwiki',
enabled = false,
cmd = { 'VimwikiIndex', 'VimwikiUISelect' },
keys = {
{ '<Leader>W', '<cmd>VimwikiIndex<CR>', { noremap = true } },
},
init = function()
vim.g.vimwiki_global_ext = 0
vim.g.vimwiki_use_calendar = 1
vim.g.vimwiki_hl_headers = 1
vim.g.vimwiki_hl_cb_checked = 1
vim.g.vimwiki_autowriteall = 0
vim.g.vimwiki_listsym_rejected = '✗'
vim.g.vimwiki_listsyms = '✗○◐●✓'
end,
config = function()
vim.g.vimwiki_key_mappings = {
all_maps = 1,
global = 1,
headers = 1,
text_objs = 1,
table_format = 1,
table_mappings = 1,
lists = 1,
links = 1,
html = 1,
mouse = 0,
}
vim.g.vimwiki_list = {
{
diary_header = 'Diary',
diary_link_fmt = '%Y-%m/%d',
auto_toc = 1,
path = '~/docs/wiki/',
syntax = 'markdown',
ext = '.md',
},
{ path = '~/docs/books/', syntax = 'markdown', ext = '.md' },
{ path = '~/notes/', syntax = 'markdown', ext = '.md' },
}
end,
},
}

12
lua/plex/plugins/extras/treesitter/treesj.lua
View File

@ -1,12 +0,0 @@
return {
{
'Wansmer/treesj',
enabled = true,
lazy = false,
cmd = { 'TSJJoin', 'TSJSplit' },
keys = {
{ '<leader>sj', '<cmd>TSJJoin<CR>' },
{ '<leader>sk', '<cmd>TSJSplit<CR>' },
},
},
}

28
lua/plex/plugins/extras/ui/barbecue.lua
View File

@ -1,28 +0,0 @@
return {
{
'utilyre/barbecue.nvim',
dependencies = { 'SmiteshP/nvim-navic', 'nvim-tree/nvim-web-devicons' },
keys = {
{
'<Leader>ub',
function()
local off = vim.b['barbecue_entries'] == nil
require('barbecue.ui').toggle(off and true or nil)
end,
desc = 'Breadcrumbs toggle',
},
},
opts = function()
local kind_icons = vim.tbl_map(function(icon)
return vim.trim(icon)
end, require('plex.config').icons.kinds)
return {
attach_navic = false,
show_dirname = false,
show_modified = true,
kinds = kind_icons,
symbols = { separator = '' },
}
end,
},
}

45
lua/plex/plugins/extras/ui/bufferline.lua
View File

@ -1,45 +0,0 @@
return {
{
'akinsho/bufferline.nvim',
event = 'VeryLazy',
opts = {
options = {
mode = 'tabs',
separator_style = 'slant',
show_close_icon = false,
show_buffer_close_icons = false,
diagnostics = false,
always_show_bufferline = true,
diagnostics_indicator = function(_, _, diag)
local icons = require('plex.config').icons.diagnostics
local ret = (diag.error and icons.Error .. diag.error .. ' ' or '')
.. (diag.warning and icons.Warn .. diag.warning or '')
return vim.trim(ret)
end,
custom_areas = {
right = function()
local project_root = require('plex.lib.badge').project()
local result = {}
local part = {}
part.text = '%#BufferLineTab# ' .. project_root
table.insert(result, part)
-- Session indicator
if vim.v['this_session'] ~= '' then
table.insert(result, { text = '%#BufferLineTab#  ' })
end
return result
end,
},
offsets = {
{
filetype = 'neo-tree',
text = 'Neo-tree',
highlight = 'Directory',
text_align = 'center',
},
},
},
},
},
}

47
lua/plex/plugins/extras/ui/cursorword.lua
View File

@ -1,47 +0,0 @@
return {
{
'itchyny/vim-cursorword',
event = 'FileType',
init = function()
vim.g.cursorword = 0
end,
config = function()
local augroup = vim.api.nvim_create_augroup('plex_cursorword', {})
vim.api.nvim_create_autocmd('FileType', {
group = augroup,
pattern = {
'conf',
'dosini',
'json',
'markdown',
'nginx',
'text',
'yaml',
},
callback = function()
if vim.wo.diff or vim.wo.previewwindow then
vim.b.cursorword = 0
else
vim.b.cursorword = 1
end
end,
})
vim.api.nvim_create_autocmd('InsertEnter', {
group = augroup,
callback = function()
if vim.b['cursorword'] == 1 then
vim.b['cursorword'] = 0
end
end,
})
vim.api.nvim_create_autocmd('InsertLeave', {
group = augroup,
callback = function()
if vim.b['cursorword'] == 0 then
vim.b['cursorword'] = 1
end
end,
})
end,
},
}

21
lua/plex/plugins/extras/ui/cybu.lua
View File

@ -1,21 +0,0 @@
return {
{
'ghillb/cybu.nvim',
dependencies = { 'nvim-tree/nvim-web-devicons', 'nvim-lua/plenary.nvim' },
keys = {
{ '[b', '<Plug>(CybuPrev)' },
{ ']b', '<Plug>(CybuNext)' },
{ '<C-S-Tab>', '<Plug>(CybuLastusedPrev)' },
{ '<C-Tab>', '<Plug>(CybuLastusedNext)' },
},
config = true,
},
{
'echasnovski/mini.bracketed',
optional = true,
opts = function(_, opts)
opts.buffer = { suffix = '' }
return opts
end,
},
}

85
lua/plex/plugins/extras/ui/dashboard.lua
View File

@ -1,85 +0,0 @@
local function get_header()
-- see https://github.com/MaximilianLloyd/ascii.nvim
return {
-- The following is a customized version!
[[ ]],
[[  ]],
[[ █ ███████ █████ ██ ]],
[[ ███ █████ █████  ]],
[[ █████ ███ ███████████████████ ███ ███████████ ]],
[[ ██ ██ █ ███ █████████████ █████ ██████████████ ]],
[[ ████ ████ ██████████ █████████ █████ █████ ████ █████ ]],
[[ ██████ ██ ███ ███ █████████ █████ █████ ████ █████ ]],
[[ ████████  ██████████████████ ████ █████ █████ ████ ██████ ]],
[[ ]],
}
end
return {
{
'glepnir/dashboard-nvim',
event = 'VimEnter',
config = function()
require('dashboard').setup({
theme = 'hyper',
config = {
header = get_header(),
week_header = {
enable = false,
},
shortcut = {
{
desc = '󰊳 Update',
group = '@property',
action = 'Lazy update',
key = 'u'
},
{
icon = '',
icon_hl = '@variable',
desc = 'Files',
group = 'Label',
action = 'Telescope find_files',
key = 'f',
},
{
desc = ' Git',
group = 'Label',
action = function()
local Util = require('plex.lib.utils')
Util.float_term({ 'lazygit'}, { cwd = Util.get_root() })
end,
key = 'g',
},
{
desc = ' Neorg',
group = 'Number',
action = 'Neorg workspace main',
key = 'o',
},
{
desc = '󰘁 Sessions',
group = 'Number',
action = 'Telescope persisted',
key = 's',
},
},
project = {
enable = true,
limit = 8,
icon = '',
label = ' Projects',
action = 'Telescope find_files cwd='
},
packages = { enable = true},
mru = { limit = 10, icon = '', label = ' Last Edited'},
-- footer = { 'footer bar foo' },
},
})
end,
dependencies = { {'nvim-tree/nvim-web-devicons'}}
}
}

9
lua/plex/plugins/extras/ui/deadcolumn.lua
View File

@ -1,9 +0,0 @@
return {
{
'Bekaboo/deadcolumn.nvim',
event = { 'BufReadPre', 'BufNewFile' },
opts = {
scope = 'visible',
},
},
}

51
lua/plex/plugins/extras/ui/goto-preview.lua
View File

@ -1,51 +0,0 @@
return {
{
'rmagatti/goto-preview',
dependencies = 'nvim-telescope/telescope.nvim',
keys = {
{
'gpd',
function()
require('goto-preview').goto_preview_definition({})
end,
{ noremap = true },
},
{
'gpi',
function()
require('goto-preview').goto_preview_implementation({})
end,
{ noremap = true },
},
{
'gpc',
function()
require('goto-preview').close_all_win()
end,
{ noremap = true },
},
{
'gpr',
function()
require('goto-preview').goto_preview_references({})
end,
{ noremap = true },
},
},
opts = {
width = 78,
height = 15,
default_mappings = false,
opacity = 10,
post_open_hook = function(_, win)
vim.api.nvim_win_set_config(win, {
border = { '╭', '─', '╮', '│', '╯', '─', '╰', '│' },
})
local scope = { scope = 'local', win = win }
vim.api.nvim_set_option_value('spell', false, scope)
vim.api.nvim_set_option_value('signcolumn', 'no', scope)
vim.keymap.set('n', '<Esc>', '<cmd>quit<CR>')
end,
},
},
}

7
lua/plex/plugins/extras/ui/incline.lua
View File

@ -1,7 +0,0 @@
return {
{
'b0o/incline.nvim',
event = 'FileType',
opts = {},
},
}

19
lua/plex/plugins/extras/ui/minimap.lua
View File

@ -1,19 +0,0 @@
return {
{
'echasnovski/mini.map',
keys = {
{ '<Leader>mn', '<cmd>lua MiniMap.toggle()<CR>', desc = 'Mini map' },
},
opts = function()
local minimap = require('mini.map')
return {
integrations = {
minimap.gen_integration.diagnostic(),
minimap.gen_integration.builtin_search(),
minimap.gen_integration.gitsigns(),
},
window = { winblend = 50 },
}
end,
},
}

24
lua/plex/plugins/extras/ui/statuscol.lua
View File

@ -1,24 +0,0 @@
return {
{
'luukvbaal/statuscol.nvim',
event = 'BufReadPost',
init = function()
vim.opt_global.foldcolumn = '1'
end,
opts = function()
local builtin = require('statuscol.builtin')
return {
setopt = true,
relculright = true,
segments = {
{
sign = { name = { '.*' }, maxwidth = 2, colwidth = 1, auto = true },
click = 'v:lua.ScSa',
},
{ text = { builtin.lnumfunc }, click = 'v:lua.ScLa' },
{ text = { builtin.foldfunc }, click = 'v:lua.ScFa' },
},
}
end,
},
}

10
lua/plex/plugins/extras/ui/vim-smoothie.lua
View File

@ -1,10 +0,0 @@
return {
{
'psliwka/vim-smoothie',
lazy = true,
keys = {
{ "J", '<cmd>call smoothie#do("\\<C-D>") <CR>', mode = {'n', 'v', 'x'}, desc = "Scroll down" },
{ "K", '<cmd>call smoothie#do("\\<C-U>") <CR>', mode = {'n', 'v', 'x'}, desc = "Scroll up" },
},
},
}

246
lua/plex/plugins/git.lua
View File

@ -1,246 +0,0 @@
-- Plugins: Git
-- https://github.com/rafi/vim-config
return {
-----------------------------------------------------------------------------
{
'lewis6991/gitsigns.nvim',
event = { 'BufReadPre', 'BufNewFile' },
-- See: https://github.com/lewis6991/gitsigns.nvim#usage
-- stylua: ignore
opts = {
signcolumn = true, -- Toggle with `:Gitsigns toggle_signs`
numhl = false, -- Toggle with `:Gitsigns toggle_numhl`
linehl = false, -- Toggle with `:Gitsigns toggle_linehl`
word_diff = false, -- Toggle with `:Gitsigns toggle_word_diff`
current_line_blame = false, -- Toggle with `:Gitsigns toggle_current_line_blame`
attach_to_untracked = true,
watch_gitdir = {
interval = 1000,
follow_files = true,
},
preview_config = {
border = 'rounded',
},
on_attach = function(bufnr)
local gs = package.loaded.gitsigns
local function map(mode, l, r, opts)
opts = opts or {}
opts.buffer = bufnr
vim.keymap.set(mode, l, r, opts)
end
-- Navigation
---@return string
map('n', ']g', function()
if vim.wo.diff then return ']c' end
vim.schedule(function() gs.next_hunk() end)
return '<Ignore>'
end, { expr = true, desc = 'Git hunk forward' })
map('n', '[g', function()
if vim.wo.diff then return '[c' end
vim.schedule(function() gs.prev_hunk() end)
return '<Ignore>'
end, { expr = true, desc = 'Git hunk last' })
-- Actions
--
map('n', '<leader>hs', gs.stage_hunk, { silent = true, desc = 'Stage hunk' })
map('n', '<leader>hr', gs.reset_hunk, { silent = true, desc = 'Reset hunk' })
map('x', '<leader>hs', function() gs.stage_hunk({vim.fn.line('.'), vim.fn.line('v')}) end)
map('x', '<leader>hr', function() gs.reset_hunk({vim.fn.line('.'), vim.fn.line('v')}) end)
map('n', '<leader>hS', gs.stage_buffer, { silent = true, desc = 'Stage buffer' })
map('n', '<leader>hu', gs.undo_stage_hunk, { desc = 'Undo staged hunk' })
map('n', '<leader>hR', gs.reset_buffer, { desc = 'Reset buffer' })
map('n', 'gs', gs.preview_hunk, { desc = 'Preview hunk' })
map('n', '<leader>hp', gs.preview_hunk_inline, { desc = 'Preview hunk inline' })
map('n', '<leader>hb', function() gs.blame_line({ full=true }) end, { desc = 'Show blame commit' })
map('n', '<leader>tb', gs.toggle_current_line_blame, { desc = 'Toggle Git line blame' })
-- map('n', '<leader>tw', gs.toggle_word_diff)
map('n', '<leader>hd', gs.diffthis, { desc = 'Diff against the index' })
map('n', '<leader>hD', function() gs.diffthis('~') end, { desc = 'Diff against the last commit' })
map('n', '<leader>td', gs.toggle_deleted, { desc = 'Toggle Git deleted' })
map('n', '<leader>hl', function()
if vim.bo.filetype ~= 'qf' then
require('gitsigns').setqflist(0, { use_location_list = true })
end
end, { desc = 'Send to location list' })
-- Text object
map({'o', 'x'}, 'ih', ':<C-U>Gitsigns select_hunk<CR>', { silent = true, desc = 'Select hunk'})
end,
},
},
-----------------------------------------------------------------------------
{
'sindrets/diffview.nvim',
cmd = { 'DiffviewOpen', 'DiffviewFileHistory' },
keys = {
{ '<Leader>gd', '<cmd>DiffviewFileHistory<CR>', desc = 'Diff File' },
{ '<Leader>gv', '<cmd>DiffviewOpen<CR>', desc = 'Diff View' },
},
opts = function()
local actions = require('diffview.actions')
vim.api.nvim_create_autocmd({ 'WinEnter', 'BufEnter' }, {
group = vim.api.nvim_create_augroup('plex_diffview', {}),
pattern = 'diffview:///panels/*',
callback = function()
vim.opt_local.cursorline = true
vim.opt_local.winhighlight = 'CursorLine:WildMenu'
end,
})
return {
enhanced_diff_hl = true, -- See ':h diffview-config-enhanced_diff_hl'
keymaps = {
view = {
{ 'n', 'q', '<cmd>DiffviewClose<CR>' },
{ 'n', '<Tab>', actions.select_next_entry },
{ 'n', '<S-Tab>', actions.select_prev_entry },
{ 'n', '<LocalLeader>a', actions.focus_files },
{ 'n', '<LocalLeader>e', actions.toggle_files },
},
file_panel = {
{ 'n', 'q', '<cmd>DiffviewClose<CR>' },
{ 'n', 'h', actions.prev_entry },
{ 'n', 'o', actions.focus_entry },
{ 'n', 'gf', actions.goto_file },
{ 'n', 'sg', actions.goto_file_split },
{ 'n', 'st', actions.goto_file_tab },
{ 'n', '<C-r>', actions.refresh_files },
{ 'n', ';e', actions.toggle_files },
},
file_history_panel = {
{ 'n', 'q', '<cmd>DiffviewClose<CR>' },
{ 'n', 'o', actions.focus_entry },
{ 'n', 'O', actions.options },
},
},
}
end,
},
-----------------------------------------------------------------------------
{
'NeogitOrg/neogit',
dependencies = {
'sindrets/diffview.nvim',
'nvim-telescope/telescope.nvim'
},
cmd = 'Neogit',
keys = {
{ '<Leader>mg', '<cmd>Neogit<CR>', desc = 'Neogit' },
},
-- See: https://github.com/TimUntersberger/neogit#configuration
opts = {
disable_signs = false,
disable_context_highlighting = false,
disable_commit_confirmation = false,
signs = {
section = { '>', 'v' },
item = { '>', 'v' },
hunk = { '', '' },
},
integrations = {
diffview = true,
},
},
},
-----------------------------------------------------------------------------
{
'FabijanZulj/blame.nvim',
cmd = 'ToggleBlame',
-- stylua: ignore
keys = {
{ '<leader>gb', '<cmd>ToggleBlame virtual<CR>', desc = 'Git blame' },
{ '<leader>gB', '<cmd>ToggleBlame window<CR>', desc = 'Git blame (window)' },
},
opts = {
date_format = '%Y-%m-%d %H:%M',
},
},
-----------------------------------------------------------------------------
{
'rhysd/git-messenger.vim',
cmd = 'GitMessenger',
keys = {
{ '<Leader>gm', '<Plug>(git-messenger)', desc = 'Git messenger'}
},
init = function()
vim.g.git_messenger_include_diff = 'current'
vim.g.git_messenger_no_default_mappings = false
vim.g.git_messenger_floating_win_opts = { border = 'rounded' }
end,
},
-----------------------------------------------------------------------------
{
'ruifm/gitlinker.nvim',
keys = {
{
'<leader>go',
function()
require('gitlinker').get_buf_range_url('n')
end,
silent = true,
desc = 'Git open in browser',
},
{
'<leader>go',
function()
require('gitlinker').get_buf_range_url('v')
end,
mode = 'x',
desc = 'Git open in browser',
},
},
opts = {
mappings = nil,
opts = {
add_current_line_on_normal_mode = true,
print_url = false,
action_callback = function(...)
return require('gitlinker.actions').open_in_browser(...)
end,
},
},
},
-----------------------------------------------------------------------------
{
'rhysd/committia.vim',
event = 'BufReadPre COMMIT_EDITMSG',
init = function()
-- See: https://github.com/rhysd/committia.vim#variables
vim.g.committia_min_window_width = 30
vim.g.committia_edit_window_width = 75
end,
config = function()
vim.g.committia_hooks = {
edit_open = function()
vim.cmd.resize(10)
local opts = {
buffer = vim.api.nvim_get_current_buf(),
silent = true,
}
local function imap(lhs, rhs)
vim.keymap.set('i', lhs, rhs, opts)
end
imap('<C-d>', '<Plug>(committia-scroll-diff-down-half)')
imap('<C-u>', '<Plug>(committia-scroll-diff-up-half)')
imap('<C-f>', '<Plug>(committia-scroll-diff-down-page)')
imap('<C-b>', '<Plug>(committia-scroll-diff-up-page)')
imap('<C-j>', '<Plug>(committia-scroll-diff-down)')
imap('<C-k>', '<Plug>(committia-scroll-diff-up)')
end,
}
end,
},
}

166
lua/plex/plugins/lsp/format.lua
View File

@ -1,166 +0,0 @@
-- LSP: Auto-format on save
-- https://github.com/rafi/vim-config
-- This is part of LazyVim's code, with my modifications.
-- See: https://github.com/LazyVim/LazyVim/blob/main/lua/lazyvim/plugins/lsp/format.lua
local M = {}
---@type PluginLspOpts
M.opts = nil
function M.enabled()
return M.opts.autoformat
end
function M.toggle()
if vim.b.autoformat == false then
vim.b.autoformat = nil
M.opts.autoformat = true
else
M.opts.autoformat = not M.opts.autoformat
end
local msg = M.opts.autoformat and 'Enabled' or 'Disabled'
vim.notify(
msg .. ' format on save',
vim.log.levels.INFO,
{ title = 'Format' }
)
end
---@param opts? {force?:boolean}
function M.format(opts)
local buf = vim.api.nvim_get_current_buf()
if vim.b.autoformat == false and not (opts and opts.force) then
return
end
local formatters = M.get_formatters(buf)
local client_ids = vim.tbl_map(function(client)
return client.id
end, formatters.active)
if #client_ids == 0 then
return
end
if M.opts.format_notify then
M.notify(formatters)
end
vim.lsp.buf.format(vim.tbl_deep_extend('force', {
bufnr = buf,
filter = function(client)
return vim.tbl_contains(client_ids, client.id)
end,
}, require('plex.lib.utils').opts('nvim-lspconfig').format or {}))
end
---@param formatters LazyVimFormatters
function M.notify(formatters)
local lines = { '# Active:' }
for _, client in ipairs(formatters.active) do
local line = '- **' .. client.name .. '**'
if client.name == 'null-ls' then
line = line
.. ' ('
.. table.concat(
vim.tbl_map(function(f)
return '`' .. f.name .. '`'
end, formatters.null_ls),
', '
)
.. ')'
end
table.insert(lines, line)
end
if #formatters.available > 0 then
table.insert(lines, '')
table.insert(lines, '# Disabled:')
for _, client in ipairs(formatters.available) do
table.insert(lines, '- **' .. client.name .. '**')
end
end
vim.notify(table.concat(lines, '\n'), vim.log.levels.INFO, {
title = 'Formatting',
on_open = function(win)
local scope = { scope = 'local', win = win }
vim.api.nvim_set_option_value('conceallevel', 3, scope)
vim.api.nvim_set_option_value('spell', false, scope)
local buf = vim.api.nvim_win_get_buf(win)
vim.treesitter.start(buf, 'markdown')
end,
})
end
-- Gets all lsp clients that support formatting.
-- When a null-ls formatter is available for the current filetype,
-- only null-ls formatters are returned.
function M.get_formatters(bufnr)
local ft = vim.bo[bufnr].filetype
-- check if we have any null-ls formatters for the current filetype
local null_ls = package.loaded['null-ls']
and require('null-ls.sources').get_available(ft, 'NULL_LS_FORMATTING')
or {}
---@class LazyVimFormatters
local ret = {
---@type lsp.Client[]
active = {},
---@type lsp.Client[]
available = {},
null_ls = null_ls,
}
local clients
if vim.lsp.get_clients ~= nil then
clients = vim.lsp.get_clients({ bufnr = bufnr })
else
---@diagnostic disable-next-line: deprecated
clients = vim.lsp.get_active_clients({ bufnr = bufnr })
end
for _, client in ipairs(clients) do
if M.supports_format(client) then
if (#null_ls > 0 and client.name == 'null-ls') or #null_ls == 0 then
table.insert(ret.active, client)
else
table.insert(ret.available, client)
end
end
end
return ret
end
-- Gets all lsp clients that support formatting
-- and have not disabled it in their client config
---@param client lsp.Client
function M.supports_format(client)
if
client.config
and client.config.capabilities
and client.config.capabilities['documentFormattingProvider'] == false
then
return false
end
return client.supports_method('textDocument/formatting')
or client.supports_method('textDocument/rangeFormatting')
end
---@param opts PluginLspOpts
function M.setup(opts)
M.opts = opts
vim.api.nvim_create_autocmd('BufWritePre', {
group = vim.api.nvim_create_augroup('plex_format', {}),
callback = function()
if M.opts.autoformat then
M.format()
end
end,
})
end
return M

47
lua/plex/plugins/lsp/highlight.lua
View File

@ -1,47 +0,0 @@
-- LSP: Highlights
-- https://github.com/rafi/vim-config
-- This is part of LunarVim's code, with my modifications.
-- Reference: https://github.com/LunarVim/LunarVim
local M = {}
---@param client lsp.Client
---@param bufnr integer
function M.on_attach(client, bufnr)
if require('plex.lib.utils').has('vim-illuminate') then
-- Skipped setup for document_highlight, illuminate is installed.
return
end
local status_ok, highlight_supported = pcall(function()
return client.supports_method('textDocument/documentHighlight')
end)
if not status_ok or not highlight_supported then
return
end
local group_name = 'lsp_document_highlight'
local ok, hl_autocmds = pcall(vim.api.nvim_get_autocmds, {
group = group_name,
buffer = bufnr,
event = 'CursorHold',
})
if ok and #hl_autocmds > 0 then
return
end
vim.api.nvim_create_augroup(group_name, { clear = false })
vim.api.nvim_create_autocmd('CursorHold', {
group = group_name,
buffer = bufnr,
callback = vim.lsp.buf.document_highlight,
})
vim.api.nvim_create_autocmd('CursorMoved', {
group = group_name,
buffer = bufnr,
callback = vim.lsp.buf.clear_references,
})
end
return M

326
lua/plex/plugins/lsp/init.lua
View File

@ -1,326 +0,0 @@
-- LSP: Plugins
-- https://github.com/rafi/vim-config
-- This is part of LazyVim's code, with my modifications.
-- See: https://github.com/LazyVim/LazyVim/blob/main/lua/lazyvim/plugins/lsp/init.lua
return {
-----------------------------------------------------------------------------
{
'neovim/nvim-lspconfig',
event = { 'BufReadPre', 'BufNewFile' },
dependencies = {
{ 'folke/neoconf.nvim', cmd = 'Neoconf', config = false, dependencies = { 'nvim-lspconfig' } },
{ 'folke/neodev.nvim', opts = {} },
'williamboman/mason.nvim',
'williamboman/mason-lspconfig.nvim',
{
'hrsh7th/cmp-nvim-lsp',
cond = function()
return require('plex.lib.utils').has('nvim-cmp')
end,
},
},
---@class PluginLspOpts
opts = {
-- Options for vim.diagnostic.config()
diagnostics = {
signs = true,
underline = true,
update_in_insert = false,
virtual_text = {
spacing = 4,
source = 'if_many',
prefix = '●',
},
severity_sort = true,
float = {
show_header = true,
border = 'rounded',
source = 'always',
},
},
-- Enable this to enable the builtin LSP inlay hints on Neovim >= 0.10.0
-- Be aware that you also will need to properly configure your LSP server to
-- provide the inlay hints.
inlay_hints = {
enabled = false,
},
-- Add any global capabilities here
capabilities = {},
-- Automatically format on save
autoformat = false,
-- Options for vim.lsp.buf.format
-- `bufnr` and `filter` is handled by the formatter,
-- but can be also overridden when specified
format = {
formatting_options = nil,
timeout_ms = nil,
},
-- Enable this to show formatters used in a notification
-- Useful for debugging formatter issues
format_notify = false,
-- LSP Server Settings
---@type lspconfig.options
---@diagnostic disable: missing-fields
servers = {
-- jsonls = {},
lua_ls = {
settings = {
Lua = {
workspace = { checkThirdParty = false },
completion = { callSnippet = 'Replace' },
},
},
},
},
-- you can do any additional lsp server setup here
-- return true if you don't want this server to be setup with lspconfig
---@type table<string, fun(server:string, opts:_.lspconfig.options):boolean?>
setup = {
-- example to setup with typescript.nvim
-- tsserver = function(_, opts)
-- require('typescript').setup({ server = opts })
-- return true
-- end,
-- Specify * to use this function as a fallback for any server
-- ['*'] = function(server, opts) end,
},
},
---@param opts PluginLspOpts
config = function(_, opts)
if require('plex.lib.utils').has('neoconf.nvim') then
local plugin = require('lazy.core.config').spec.plugins['neoconf.nvim']
require('neoconf').setup(require('lazy.core.plugin').values(plugin, 'opts', false))
end
-- Setup autoformat
require('plex.plugins.lsp.format').setup(opts)
-- Setup formatting, keymaps and highlights.
local lsp_on_attach = require('plex.lib.utils').on_attach
---@param client lsp.Client
---@param buffer integer
lsp_on_attach(function(client, buffer)
require('plex.plugins.lsp.keymaps').on_attach(client, buffer)
require('plex.plugins.lsp.highlight').on_attach(client, buffer)
if vim.diagnostic.is_disabled() or vim.bo[buffer].buftype ~= '' then
vim.diagnostic.disable(buffer)
return
end
end)
local register_capability = vim.lsp.handlers['client/registerCapability']
---@diagnostic disable-next-line: duplicate-set-field
vim.lsp.handlers['client/registerCapability'] = function(err, res, ctx)
local ret = register_capability(err, res, ctx)
local client_id = ctx.client_id
---@type lsp.Client|nil
local client = vim.lsp.get_client_by_id(client_id)
local buffer = vim.api.nvim_get_current_buf()
if client ~= nil then
require('plex.plugins.lsp.keymaps').on_attach(client, buffer)
end
return ret
end
-- Diagnostics signs and highlights
for type, icon in pairs(require('plex.config').icons.diagnostics) do
local hl = 'DiagnosticSign' .. type
vim.fn.sign_define(hl, { text = icon, texthl = hl, numhl = '' })
end
-- Setup inlay-hints
local inlay_hint = vim.lsp.buf.inlay_hint or vim.lsp.inlay_hint
if opts.inlay_hints.enabled and inlay_hint then
lsp_on_attach(function(client, buffer)
if client.supports_method('textDocument/inlayHint') then
inlay_hint(buffer, true)
end
end)
end
if
type(opts.diagnostics.virtual_text) == 'table'
and opts.diagnostics.virtual_text.prefix == 'icons'
then
opts.diagnostics.virtual_text.prefix = vim.fn.has('nvim-0.10') == 0
and '●'
or function(diagnostic)
local icons = require('plex.config').icons.diagnostics
for d, icon in pairs(icons) do
if diagnostic.severity == vim.diagnostic.severity[d:upper()] then
return icon
end
end
end
end
vim.diagnostic.config(vim.deepcopy(opts.diagnostics))
-- Initialize LSP servers and ensure Mason packages
-- Setup base config for all servers.
local servers = opts.servers
local has_cmp, cmp_nvim_lsp = pcall(require, 'cmp_nvim_lsp')
local capabilities = vim.tbl_deep_extend(
'force',
{},
vim.lsp.protocol.make_client_capabilities(),
has_cmp and cmp_nvim_lsp.default_capabilities() or {},
opts.capabilities or {}
)
-- Combine base config for each server and merge user-defined settings.
-- These can be overridden locally by lua/lsp/<server_name>.lua
---@param server_name string
local function make_config(server_name)
local server_opts = vim.tbl_deep_extend('force', {
capabilities = vim.deepcopy(capabilities),
}, servers[server_name] or {})
if opts.setup[server_name] then
if opts.setup[server_name](server_name, server_opts) then
return
end
elseif opts.setup['*'] then
if opts.setup['*'](server_name, server_opts) then
return
end
end
local exists, module = pcall(require, 'lsp.' .. server_name)
if exists and module ~= nil then
local user_config = module.config(server_opts) or {}
server_opts = vim.tbl_deep_extend('force', server_opts, user_config)
end
require('lspconfig')[server_name].setup(server_opts)
end
-- Get all the servers that are available thourgh mason-lspconfig
local have_mason, mlsp = pcall(require, 'mason-lspconfig')
local all_mslp_servers = {}
if have_mason then
all_mslp_servers = vim.tbl_keys(
require('mason-lspconfig.mappings.server').lspconfig_to_package
)
end
local ensure_installed = {} ---@type string[]
for server, server_opts in pairs(servers) do
if server_opts then
server_opts = server_opts == true and {} or server_opts
-- run manual setup if mason=false or if this is a server that cannot
-- be installed with mason-lspconfig
if
server_opts.mason == false
or not vim.tbl_contains(all_mslp_servers, server)
then
make_config(server)
else
ensure_installed[#ensure_installed + 1] = server
end
end
end
if have_mason then
mlsp.setup({
ensure_installed = ensure_installed,
handlers = { make_config },
})
end
-- Enable rounded borders in :LspInfo window.
require('lspconfig.ui.windows').default_options.border = 'rounded'
end,
},
-----------------------------------------------------------------------------
{
'williamboman/mason.nvim',
cmd = 'Mason',
build = ':MasonUpdate',
keys = { { '<leader>mm', '<cmd>Mason<cr>', desc = 'Mason' } },
opts = {
ensure_installed = {},
ui = {
border = 'rounded',
},
},
---@param opts MasonSettings | {ensure_installed: string[]}
config = function(_, opts)
require('mason').setup(opts)
local mr = require('mason-registry')
local function ensure_installed()
for _, tool in ipairs(opts.ensure_installed) do
local p = mr.get_package(tool)
if not p:is_installed() then
p:install()
end
end
end
if mr.refresh then
mr.refresh(ensure_installed)
else
ensure_installed()
end
end,
},
-----------------------------------------------------------------------------
{
'mhartington/formatter.nvim',
event = { 'BufReadPre', 'BufNewFile' },
dependencies = { 'williamboman/mason.nvim', 'neovim/nvim-lspconfig' },
opts = function(_, opts)
opts = opts or {}
local defaults = {
logging = true,
log_level = vim.log.levels.WARN,
filetype = {
lua = { require('formatter.filetypes.lua').stylua },
},
}
opts = vim.tbl_extend('keep', opts, defaults)
return opts
end,
config = true,
},
-----------------------------------------------------------------------------
{
'dnlhc/glance.nvim',
cmd = 'Glance',
keys = {
{ 'gpd', '<cmd>Glance definitions<CR>' },
{ 'gpr', '<cmd>Glance references<CR>' },
{ 'gpy', '<cmd>Glance type_definitions<CR>' },
{ 'gpi', '<cmd>Glance implementations<CR>' },
},
opts = function()
local actions = require('glance').actions
return {
folds = {
fold_closed = '󰅂', -- 󰅂 
fold_open = '󰅀', -- 󰅀 
folded = true,
},
mappings = {
list = {
['<C-u>'] = actions.preview_scroll_win(5),
['<C-d>'] = actions.preview_scroll_win(-5),
['sg'] = actions.jump_vsplit,
['sv'] = actions.jump_split,
['st'] = actions.jump_tab,
['p'] = actions.enter_win('preview'),
},
preview = {
['q'] = actions.close,
['p'] = actions.enter_win('list'),
},
},
}
end,
},
}

178
lua/plex/plugins/lsp/keymaps.lua
View File

@ -1,178 +0,0 @@
-- LSP: Key-maps
-- https://github.com/rafi/vim-config
local M = {}
---@type PluginLspKeys
M._keys = nil
---@return (LazyKeys|{has?:string})[]
function M.get()
if M._keys then
return M._keys
end
local format = function()
require('plex.plugins.lsp.format').format({ force = true })
end
---@class PluginLspKeys
-- stylua: ignore
M._keys = {
{ 'gD', vim.lsp.buf.declaration, desc = 'Goto Declaration', has = 'declaration' },
{ 'gd', vim.lsp.buf.definition, desc = 'Goto Definition', has = 'definition' },
{ 'gr', vim.lsp.buf.references, desc = 'References', has = 'references' },
{ 'gy', vim.lsp.buf.type_definition, desc = 'Goto Type Definition', has = 'typeDefinition' },
{ 'gi', vim.lsp.buf.implementation, desc = 'Goto Implementation', has = 'implementation' },
{ 'gK', vim.lsp.buf.signature_help, desc = 'Signature Help', has = 'signatureHelp' },
{ '<C-g>h', vim.lsp.buf.signature_help, mode = 'i', desc = 'Signature Help', has = 'signatureHelp' },
{ ']d', M.diagnostic_goto(true), desc = 'Next Diagnostic' },
{ '[d', M.diagnostic_goto(false), desc = 'Prev Diagnostic' },
{ ']e', M.diagnostic_goto(true, 'ERROR'), desc = 'Next Error' },
{ '[e', M.diagnostic_goto(false, 'ERROR'), desc = 'Prev Error' },
{ ',wa', vim.lsp.buf.add_workspace_folder, desc = 'Show Workspace Folders' },
{ ',wr', vim.lsp.buf.remove_workspace_folder, desc = 'Remove Workspace Folder' },
{ ',wl', '<cmd>lua =vim.lsp.buf.list_workspace_folders()<CR>', desc = 'List Workspace Folders' },
{ '<localleader>K', function()
-- Show hover documentation or folded lines.
local winid = require('plex.lib.utils').has('nvim-ufo')
and require('ufo').peekFoldedLinesUnderCursor() or nil
if not winid then
vim.lsp.buf.hover()
end
end },
{ '<Leader>ud', function() M.diagnostic_toggle(false) end, desc = 'Disable Diagnostics' },
{ '<Leader>uD', function() M.diagnostic_toggle(true) end, desc = 'Disable All Diagnostics' },
{ '<leader>cl', '<cmd>LspInfo<cr>' },
{ '<leader>cf', format, desc = 'Format Document', has = 'formatting' },
{ '<leader>cf', format, mode = 'x', desc = 'Format Range' }, -- , has = 'rangeFormatting'
{ '<Leader>cr', vim.lsp.buf.rename, desc = 'Rename', has = 'rename' },
{ '<Leader>ce', vim.diagnostic.open_float, desc = 'Open diagnostics' },
{ '<Leader>ca', vim.lsp.buf.code_action, mode = { 'n', 'x' }, has = 'codeAction', desc = 'Code Action' },
{ '<Leader>cA', function()
vim.lsp.buf.code_action({
context = {
only = { 'source' },
diagnostics = {},
},
})
end, desc = 'Source Action', has = 'codeAction' },
}
return M._keys
end
---@param method string
function M.has(buffer, method)
method = method:find('/') and method or 'textDocument/' .. method
local clients
if vim.lsp.get_clients ~= nil then
clients = vim.lsp.get_clients({ bufnr = buffer })
else
---@diagnostic disable-next-line: deprecated
clients = vim.lsp.get_active_clients({ bufnr = buffer })
end
for _, client in ipairs(clients) do
if client.supports_method(method) then
return true
end
end
return false
end
---@param buffer integer
function M.resolve(buffer)
local Keys = require('lazy.core.handler.keys')
local keymaps = {} ---@type table<string,LazyKeys|{has?:string}>
local function add(keymap)
local keys = Keys.parse(keymap)
if keys[2] == false then
keymaps[keys.id] = nil
else
keymaps[keys.id] = keys
end
end
for _, keymap in ipairs(M.get()) do
add(keymap)
end
local opts = require('plex.lib.utils').opts('nvim-lspconfig')
local clients
if vim.lsp.get_clients ~= nil then
clients = vim.lsp.get_clients({ bufnr = buffer })
else
---@diagnostic disable-next-line: deprecated
clients = vim.lsp.get_active_clients({ bufnr = buffer })
end
for _, client in ipairs(clients) do
local maps = opts.servers[client.name] and opts.servers[client.name].keys
or {}
for _, keymap in ipairs(maps) do
add(keymap)
end
end
return keymaps
end
---@param client lsp.Client
---@param buffer integer
function M.on_attach(client, buffer)
local Keys = require('lazy.core.handler.keys')
local keymaps = M.resolve(buffer)
for _, keys in pairs(keymaps) do
if not keys.has or M.has(buffer, keys.has) then
local opts = Keys.opts(keys)
---@diagnostic disable-next-line: no-unknown
opts.has = nil
opts.silent = opts.silent ~= false
opts.buffer = buffer
vim.keymap.set(keys.mode or 'n', keys[1], keys[2], opts)
end
end
end
-- Toggle diagnostics locally (false) or globally (true).
---@param global boolean
function M.diagnostic_toggle(global)
local bufnr, cmd, msg, state
if global then
bufnr = nil
state = vim.g.diagnostics_disabled
vim.g.diagnostics_disabled = not state
else
bufnr = 0
if vim.fn.has('nvim-0.9') == 1 then
state = vim.diagnostic.is_disabled(bufnr)
else
state = vim.b.diagnostics_disabled
vim.b.diagnostics_disabled = not state
end
end
cmd = state and 'enable' or 'disable'
msg = cmd:gsub('^%l', string.upper) .. 'd diagnostics'
if global then
msg = msg .. ' globally'
end
vim.notify(msg)
vim.schedule(function()
vim.diagnostic[cmd](bufnr)
end)
end
---@param next boolean
---@param severity string|nil
---@return fun()
function M.diagnostic_goto(next, severity)
local go = next and vim.diagnostic.goto_next or vim.diagnostic.goto_prev
local severity_int = severity and vim.diagnostic.severity[severity] or nil
return function()
go({ severity = severity_int })
end
end
return M

285
lua/plex/plugins/lualine.lua
View File

@ -1,285 +0,0 @@
-- Plugin: Lualine
-- https://github.com/rafi/vim-config
return {
-----------------------------------------------------------------------------
{
'nvim-lualine/lualine.nvim',
dependencies = {
'nvim-lua/plenary.nvim',
'nvim-tree/nvim-web-devicons',
},
event = 'VeryLazy',
init = function()
vim.g.qf_disable_statusline = true
end,
opts = function()
local icons = require('plex.config').icons
local get_color = require('plex.lib.color').get_color
local fg = function(...) return { fg = get_color('fg', ...) } end
local function filepath()
local fpath = require('plex.lib.badge').filepath(0, 3, 5)
-- % char must be escaped in statusline.
return fpath:gsub('%%', '%%%%')
end
local function is_file_window()
return vim.bo.buftype == ''
end
local function is_min_width(min)
if vim.o.laststatus > 2 then
return vim.o.columns > min
end
return vim.fn.winwidth(0) > min
end
local active = {
fg = get_color('fg', { 'StatusLine' }, '#000000'),
bg = get_color('bg', { 'StatusLine' }, '#000000'),
}
local inactive = {
fg = get_color('fg', { 'StatusLineNC' }, '#666656'),
bg = get_color('bg', { 'StatusLineNC' }, '#000000'),
}
local theme = {
normal = {
a = active,
b = active,
c = active,
x = active,
y = {
fg = active.fg,
bg = require('plex.lib.color').brightness_modifier(active.bg, -20),
},
z = {
fg = active.fg,
bg = require('plex.lib.color').brightness_modifier(active.bg, 63),
},
},
inactive = {
a = inactive, b = inactive, c = inactive,
x = inactive, y = inactive, z = inactive,
},
}
return {
options = {
theme = theme,
globalstatus = true,
always_divide_middle = false,
disabled_filetypes = { statusline = { 'dashboard', 'alpha' } },
component_separators = '',
section_separators = '',
},
extensions = {
'man',
},
sections = {
lualine_a = {
-- Left edge block.
{
function() return '▊' end,
color = fg({'Directory'}, '#51afef'),
padding = 0,
},
-- Readonly/zoomed/hash symbol.
{
padding = { left = 1, right = 0 },
cond = is_file_window,
function()
if vim.bo.buftype == '' and vim.bo.readonly then
return icons.status.filename.readonly
elseif vim.t['zoomed'] then
return icons.status.filename.zoomed
end
return '%*#'
end,
},
-- Buffer number.
{ function() return '%n' end, cond = is_file_window, padding = 0 },
-- Modified symbol.
{
function()
return vim.bo.modified and icons.status.filename.modified or ''
end,
cond = is_file_window,
padding = 0,
color = { fg = get_color('bg', {'DiffDelete'}, '#ec5f67') },
},
},
lualine_b = {
{
function() return require('plex.lib.badge').icon() end,
padding = { left = 1, right = 0 },
},
{
filepath,
padding = 1,
color = { fg = '#D7D7BC' },
separator = '',
},
{
'branch',
cond = is_file_window,
icon = '',
padding = 1,
},
{
function() return '#' .. vim.b['toggle_number'] end,
cond = function() return vim.bo.buftype == 'terminal' end,
},
{
function()
if vim.fn.win_gettype() == 'loclist' then
return vim.fn.getloclist(0, { title = 0 }).title
end
return vim.fn.getqflist({ title = 0 }).title
end,
cond = function() return vim.bo.filetype == 'qf' end,
padding = { left = 1, right = 0 },
},
},
lualine_c = {
{
'diagnostics',
padding = { left = 1, right = 0 },
symbols = {
error = icons.status.diagnostics.error,
warn = icons.status.diagnostics.warn,
info = icons.status.diagnostics.info,
hint = icons.status.diagnostics.hint,
},
},
-- Whitespace trails
{
function() return require('plex.lib.badge').trails('␣') end,
cond = is_file_window,
padding = { left = 1, right = 0 },
color = { fg = get_color('bg', {'Identifier'}, '#b294bb') },
},
-- Start truncating here
{ function() return '%<' end, padding = 0 },
{
'diff',
symbols = {
added = icons.status.git.added,
modified = icons.status.git.modified,
removed = icons.status.git.removed,
},
padding = { left = 1, right = 0 },
cond = function()
return is_file_window() and is_min_width(70)
end,
},
-- {
-- function() return require('nvim-navic').get_location() end,
-- padding = { left = 1, right = 0 },
-- cond = function()
-- return is_min_width(100)
-- and package.loaded['nvim-navic']
-- and require('nvim-navic').is_available()
-- end,
-- },
},
lualine_x = {
-- showcmd
{
function() return require('noice').api.status.command.get() end,
cond = function()
return package.loaded['noice']
and require('noice').api.status.command.has()
end,
color = fg({'Statement'}),
},
-- showmode
{
function() return require('noice').api.status.mode.get() end,
cond = function()
return package.loaded['noice']
and require('noice').api.status.mode.has()
end,
color = fg({'Constant'}),
},
-- search count
{
function() require('noice').api.status.search.get() end,
cond = function()
return package.loaded['noice']
and require('noice').api.status.search.has()
end,
color = { fg = "#ff9e64" },
},
-- lazy.nvim updates
{
require('lazy.status').updates,
cond = require('lazy.status').has_updates,
color = fg({'Comment'}),
separator = { left = '' },
},
},
lualine_y = {
{
function() return require('plex.lib.badge').filemedia('') end,
cond = function() return is_min_width(70) end,
separator = { left = '' },
padding = 1,
},
},
lualine_z = {
{
function()
if is_file_window() then
return '%l/%2c%4p%%'
end
return '%l/%L'
end,
cond = function()
return vim.bo.filetype ~= 'TelescopePrompt'
end,
separator = { left = '' },
padding = 1,
},
},
},
inactive_sections = {
lualine_a = {
{
function() return require('plex.lib.badge').icon() end,
padding = 1,
},
{ filepath, padding = { left = 1, right = 0 } },
{
function()
return vim.bo.modified
and vim.bo.buftype == ''
and icons.status.filename.modified
or ''
end,
cond = is_file_window,
padding = 1,
color = { fg = get_color('bg', {'DiffDelete'}, '#ec5f67') },
},
},
lualine_b = {},
lualine_c = {},
lualine_x = {},
lualine_y = {},
lualine_z = {
{ function() return vim.bo.filetype end, cond = is_file_window },
}
},
}
end,
},
}

513
lua/plex/plugins/telescope.lua
View File

@ -1,513 +0,0 @@
-- Plugin: telescope.nvim
-- https://github.com/rafi/vim-config
-- Helpers
-- Custom actions
local myactions = {}
function myactions.send_to_qflist(prompt_bufnr)
require('telescope.actions').send_to_qflist(prompt_bufnr)
vim.api.nvim_command([[ botright copen ]])
end
function myactions.smart_send_to_qflist(prompt_bufnr)
require('telescope.actions').smart_send_to_qflist(prompt_bufnr)
vim.api.nvim_command([[ botright copen ]])
end
--- Scroll the results window up
---@param prompt_bufnr number: The prompt bufnr
function myactions.results_scrolling_up(prompt_bufnr)
myactions.scroll_results(prompt_bufnr, -1)
end
--- Scroll the results window down
---@param prompt_bufnr number: The prompt bufnr
function myactions.results_scrolling_down(prompt_bufnr)
myactions.scroll_results(prompt_bufnr, 1)
end
---@param prompt_bufnr number: The prompt bufnr
---@param direction number: 1|-1
function myactions.scroll_results(prompt_bufnr, direction)
local status = require('telescope.state').get_status(prompt_bufnr)
local default_speed = vim.api.nvim_win_get_height(status.results_win) / 2
local speed = status.picker.layout_config.scroll_speed or default_speed
require('telescope.actions.set').shift_selection(
prompt_bufnr,
math.floor(speed) * direction
)
end
-- Custom pickers
local plugin_directories = function(opts)
local actions = require('telescope.actions')
local utils = require('telescope.utils')
local dir = vim.fn.stdpath('data') .. '/lazy'
opts = opts or {}
opts.cmd = vim.F.if_nil(opts.cmd, {
vim.o.shell,
'-c',
'find ' .. vim.fn.shellescape(dir) .. ' -mindepth 1 -maxdepth 1 -type d',
})
local dir_len = dir:len()
opts.entry_maker = function(line)
return {
value = line,
ordinal = line,
display = line:sub(dir_len + 2),
}
end
require('telescope.pickers')
.new(opts, {
layout_config = {
width = 0.65,
height = 0.7,
},
prompt_title = '[ Plugin directories ]',
finder = require('telescope.finders').new_table({
results = utils.get_os_command_output(opts.cmd),
entry_maker = opts.entry_maker,
}),
sorter = require('telescope.sorters').get_fuzzy_file(),
previewer = require('telescope.previewers.term_previewer').cat.new(opts),
attach_mappings = function(prompt_bufnr)
actions.select_default:replace(function()
local entry = require('telescope.actions.state').get_selected_entry()
actions.close(prompt_bufnr)
vim.cmd.tcd(entry.value)
end)
return true
end,
})
:find()
end
-- Custom window-sizes
---@param dimensions table
---@param size integer
---@return float
local function get_matched_ratio(dimensions, size)
for min_cols, scale in pairs(dimensions) do
if min_cols == 'lower' or size >= min_cols then
return math.floor(size * scale)
end
end
return dimensions.lower
end
local function width_tiny(_, cols, _)
return get_matched_ratio({ [180] = 0.27, lower = 0.37 }, cols)
end
local function width_small(_, cols, _)
return get_matched_ratio({ [180] = 0.4, lower = 0.5 }, cols)
end
local function width_medium(_, cols, _)
return get_matched_ratio({ [180] = 0.5, [110] = 0.6, lower = 0.75 }, cols)
end
local function width_large(_, cols, _)
return get_matched_ratio({ [180] = 0.7, [110] = 0.8, lower = 0.85 }, cols)
end
-- Enable indent-guides in telescope preview
vim.api.nvim_create_autocmd('User', {
pattern = 'TelescopePreviewerLoaded',
group = vim.api.nvim_create_augroup('plex_telescope', {}),
callback = function(args)
if args.buf ~= vim.api.nvim_win_get_buf(0) then
return
end
vim.opt_local.listchars = vim.wo.listchars .. ',tab:▏\\ '
vim.opt_local.conceallevel = 0
vim.opt_local.wrap = true
vim.opt_local.list = true
vim.opt_local.number = true
end,
})
-- Setup Telescope
-- See telescope.nvim/lua/telescope/config.lua for defaults.
return {
-----------------------------------------------------------------------------
{
'nvim-telescope/telescope.nvim',
cmd = 'Telescope',
commit = vim.fn.has('nvim-0.9') == 0 and '057ee0f8783' or nil,
dependencies = {
'nvim-lua/plenary.nvim',
'jvgrootveld/telescope-zoxide',
'folke/todo-comments.nvim',
'rafi/telescope-thesaurus.nvim',
},
config = function(_, opts)
require('telescope').setup(opts)
require('telescope').load_extension('persisted')
end,
-- stylua: ignore
keys = {
-- General pickers
{ '<localleader>r', '<cmd>Telescope resume initial_mode=normal<CR>', desc = 'Resume last' },
{ '<localleader>R', '<cmd>Telescope pickers<CR>', desc = 'Pickers' },
{ '<localleader>f', '<cmd>Telescope find_files<CR>', desc = 'Find files' },
{ '<localleader>g', '<cmd>Telescope live_grep<CR>', desc = 'Grep' },
{ '<localleader>b', '<cmd>Telescope buffers show_all_buffers=true<CR>', desc = 'Buffers' },
{ '<localleader>h', '<cmd>Telescope highlights<CR>', desc = 'Highlights' },
{ '<localleader>j', '<cmd>Telescope jumplist<CR>', desc = 'Jump list' },
{ '<localleader>m', '<cmd>Telescope marks<CR>', desc = 'Marks' },
{ '<localleader>o', '<cmd>Telescope vim_options<CR>', desc = 'Neovim options' },
{ '<localleader>t', '<cmd>Telescope lsp_dynamic_workspace_symbols<CR>', desc = 'Workspace symbols' },
{ '<localleader>v', '<cmd>Telescope registers<CR>', desc = 'Registers' },
{ '<localleader>u', '<cmd>Telescope spell_suggest<CR>', desc = 'Spell suggest' },
{ 'z<space>', '<cmd>Telescope spell_suggest<CR>', desc = 'Spell suggest' },
{ '<localleader>S', '<cmd>Telescope persisted<CR>', desc = 'Sessions' },
{ '<localleader>x', '<cmd>Telescope oldfiles<CR>', desc = 'Old files' },
{ '<localleader>;', '<cmd>Telescope command_history<CR>', desc = 'Command history' },
{ '<localleader>:', '<cmd>Telescope commands<CR>', desc = 'Commands' },
{ '<localleader>/', '<cmd>Telescope search_history<CR>', desc = 'Search history' },
{ '<leader>/', '<cmd>Telescope current_buffer_fuzzy_find<CR>', desc = 'Buffer find' },
{ '<leader>Sd', '<cmd>Telescope diagnostics bufnr=0<CR>', desc = 'Document diagnostics' },
{ '<leader>SD', '<cmd>Telescope diagnostics<CR>', desc = 'Workspace diagnostics' },
{ '<leader>Sh', '<cmd>Telescope help_tags<CR>', desc = 'Help Pages' },
{ '<leader>Sk', '<cmd>Telescope keymaps<CR>', desc = 'Key Maps' },
{ '<leader>Sm', '<cmd>Telescope man_pages<CR>', desc = 'Man Pages' },
{ '<leader>Sw', '<cmd>Telescope grep_string<CR>', desc = 'Word' },
{ '<leader>Sc', '<cmd>Telescope colorscheme<CR>', desc = 'Colorscheme' },
{ '<leader>uC', '<cmd>Telescope colorscheme<CR>', desc = 'Colorscheme' },
-- LSP related
{ '<localleader>dd', '<cmd>Telescope lsp_definitions<CR>', desc = 'Definitions' },
{ '<localleader>di', '<cmd>Telescope lsp_implementations<CR>', desc = 'Implementations' },
{ '<localleader>dr', '<cmd>Telescope lsp_references<CR>', desc = 'References' },
{ '<localleader>da', '<cmd>Telescope lsp_code_actions<CR>', desc = 'Code actions' },
{ '<localleader>da', ':Telescope lsp_range_code_actions<CR>', mode = 'x', desc = 'Code actions' },
{
'<leader>Ss',
function()
require('telescope.builtin').lsp_document_symbols({
symbols = {
'Class',
'Function',
'Method',
'Constructor',
'Interface',
'Module',
'Struct',
'Trait',
'Field',
'Property',
},
})
end,
desc = 'Goto Symbol',
},
{
'<leader>SS',
function()
require('telescope.builtin').lsp_dynamic_workspace_symbols({
symbols = {
'Class',
'Function',
'Method',
'Constructor',
'Interface',
'Module',
'Struct',
'Trait',
'Field',
'Property',
},
})
end,
desc = 'Goto Symbol (Workspace)',
},
-- Git
{ '<leader>gs', '<cmd>Telescope git_status<CR>', desc = 'Git status' },
{ '<leader>gr', '<cmd>Telescope git_branches<CR>', desc = 'Git branches' },
{ '<leader>gl', '<cmd>Telescope git_commits<CR>', desc = 'Git commits' },
{ '<leader>gL', '<cmd>Telescope git_bcommits<CR>', desc = 'Git buffer commits' },
{ '<leader>gh', '<cmd>Telescope git_stash<CR>', desc = 'Git stashes' },
{ '<leader>gc', '<cmd>Telescope git_bcommits_range<CR>', mode = { 'x', 'n' }, desc = 'Git bcommits range' },
-- Plugins
{ '<localleader>n', plugin_directories, desc = 'Plugins' },
{ '<localleader>k', '<cmd>Telescope thesaurus lookup<CR>', desc = 'Thesaurus' },
{ '<localleader>w', '<cmd>ZkNotes<CR>', desc = 'Zk notes' },
{
'<localleader>z',
function()
require('telescope').extensions.zoxide.list({
layout_config = { width = 0.5, height = 0.6 },
})
end,
desc = 'Zoxide (MRU)',
},
-- Find by...
{
'<leader>gt',
function()
require('telescope.builtin').lsp_workspace_symbols({
default_text = vim.fn.expand('<cword>'),
})
end,
desc = 'Find symbol',
},
{
'<leader>gf',
function()
require('telescope.builtin').find_files({
default_text = vim.fn.expand('<cword>'),
})
end,
desc = 'Find file',
},
{
'<leader>gg', function()
require('telescope.builtin').live_grep({
default_text = vim.fn.expand('<cword>'),
})
end,
desc = 'Grep cursor word',
},
{
'<leader>gg',
function()
require('telescope.builtin').live_grep({
default_text = require('plex.lib.edit').get_visual_selection(),
})
end,
mode = 'x',
desc = 'Grep cursor word',
},
},
opts = function()
local transform_mod = require('telescope.actions.mt').transform_mod
local actions = require('telescope.actions')
-- Transform to Telescope proper actions.
myactions = transform_mod(myactions)
-- Clone the default Telescope configuration and enable hidden files.
local has_ripgrep = vim.fn.executable('rg') == 1
local vimgrep_args = {
unpack(require('telescope.config').values.vimgrep_arguments),
}
table.insert(vimgrep_args, '--hidden')
table.insert(vimgrep_args, '--follow')
table.insert(vimgrep_args, '--no-ignore-vcs')
table.insert(vimgrep_args, '--glob')
table.insert(vimgrep_args, '!**/.git/*')
local find_args = {
'rg',
'--vimgrep',
'--files',
'--follow',
'--hidden',
'--no-ignore-vcs',
'--smart-case',
'--glob',
'!**/.git/*',
}
return {
defaults = {
sorting_strategy = 'ascending',
cache_picker = { num_pickers = 3 },
prompt_prefix = '', -- ❯  
selection_caret = '▍ ',
multi_icon = '',
path_display = { 'truncate' },
file_ignore_patterns = { 'node_modules' },
set_env = { COLORTERM = 'truecolor' },
vimgrep_arguments = has_ripgrep and vimgrep_args or nil,
layout_strategy = 'horizontal',
layout_config = {
prompt_position = 'top',
horizontal = {
height = 0.85,
},
},
-- stylua: ignore
mappings = {
i = {
['jj'] = { '<Esc>', type = 'command' },
['<Tab>'] = actions.move_selection_worse,
['<S-Tab>'] = actions.move_selection_better,
['<C-u>'] = actions.results_scrolling_up,
['<C-d>'] = actions.results_scrolling_down,
['<C-q>'] = myactions.smart_send_to_qflist,
['<C-n>'] = actions.cycle_history_next,
['<C-p>'] = actions.cycle_history_prev,
['<C-b>'] = actions.preview_scrolling_up,
['<C-f>'] = actions.preview_scrolling_down,
},
n = {
['q'] = actions.close,
['<Esc>'] = actions.close,
['<Tab>'] = actions.move_selection_worse,
['<S-Tab>'] = actions.move_selection_better,
['<C-u>'] = myactions.results_scrolling_up,
['<C-d>'] = myactions.results_scrolling_down,
['<C-b>'] = actions.preview_scrolling_up,
['<C-f>'] = actions.preview_scrolling_down,
['<C-n>'] = actions.cycle_history_next,
['<C-p>'] = actions.cycle_history_prev,
['*'] = actions.toggle_all,
['u'] = actions.drop_all,
['J'] = actions.toggle_selection + actions.move_selection_next,
['K'] = actions.toggle_selection + actions.move_selection_previous,
[' '] = {
actions.toggle_selection + actions.move_selection_next,
type = 'action',
opts = { nowait = true },
},
['sv'] = actions.select_horizontal,
['sg'] = actions.select_vertical,
['st'] = actions.select_tab,
['w'] = myactions.smart_send_to_qflist,
['e'] = myactions.send_to_qflist,
['!'] = actions.edit_command_line,
['t'] = function(...)
return require('trouble.providers.telescope').open_with_trouble(...)
end,
['p'] = function()
local entry = require('telescope.actions.state').get_selected_entry()
require('plex.lib.preview').open(entry.path)
end,
},
},
},
pickers = {
buffers = {
sort_lastused = true,
sort_mru = true,
show_all_buffers = true,
ignore_current_buffer = true,
layout_config = { width = width_large, height = 0.7 },
mappings = {
n = {
['dd'] = actions.delete_buffer,
},
},
},
find_files = {
find_command = has_ripgrep and find_args or nil,
},
live_grep = {
dynamic_preview_title = true,
},
colorscheme = {
enable_preview = true,
layout_config = { preview_width = 0.7 },
},
highlights = {
layout_config = { preview_width = 0.7 },
},
vim_options = {
theme = 'dropdown',
layout_config = { width = width_medium, height = 0.7 },
},
command_history = {
theme = 'dropdown',
layout_config = { width = width_medium, height = 0.7 },
},
search_history = {
theme = 'dropdown',
layout_config = { width = width_small, height = 0.6 },
},
spell_suggest = {
theme = 'cursor',
layout_config = { width = width_tiny, height = 0.45 },
},
registers = {
theme = 'cursor',
layout_config = { width = 0.35, height = 0.4 },
},
oldfiles = {
theme = 'dropdown',
previewer = false,
layout_config = { width = width_medium, height = 0.7 },
},
lsp_definitions = {
layout_config = { width = width_large, preview_width = 0.55 },
},
lsp_implementations = {
layout_config = { width = width_large, preview_width = 0.55 },
},
lsp_references = {
layout_config = { width = width_large, preview_width = 0.55 },
},
lsp_code_actions = {
theme = 'cursor',
previewer = false,
layout_config = { width = 0.3, height = 0.4 },
},
lsp_range_code_actions = {
theme = 'cursor',
previewer = false,
layout_config = { width = 0.3, height = 0.4 },
},
},
extensions = {
persisted = {
layout_config = { width = 0.55, height = 0.55 },
},
zoxide = {
prompt_title = '[ Zoxide directories ]',
mappings = {
default = {
action = function(selection)
vim.cmd.tcd(selection.path)
end,
after_action = function(selection)
vim.notify(
"Current working directory set to '"
.. selection.path
.. "'",
vim.log.levels.INFO
)
end,
},
},
},
},
}
end,
},
}

190
lua/plex/plugins/treesitter.lua
View File

@ -1,190 +0,0 @@
-- Plugins: Tree-sitter and Syntax
-- https://github.com/rafi/vim-config
return {
-----------------------------------------------------------------------------
-- Vimscript syntax/indent plugins
{ 'iloginow/vim-stylus', ft = 'stylus' },
{ 'chrisbra/csv.vim', ft = 'csv' },
{ 'mustache/vim-mustache-handlebars', ft = { 'mustache', 'handlebars' } },
{ 'lifepillar/pgsql.vim', ft = 'pgsql' },
{ 'MTDL9/vim-log-highlighting', ft = 'log' },
{ 'reasonml-editor/vim-reason-plus', ft = { 'reason', 'merlin' } },
{ 'vmchale/just-vim', ft = 'just' },
-----------------------------------------------------------------------------
{
'andymass/vim-matchup',
init = function()
vim.g.matchup_matchparen_offscreen = {}
end,
},
-----------------------------------------------------------------------------
{
'nvim-treesitter/nvim-treesitter',
event = { 'BufReadPost', 'BufNewFile' },
main = 'nvim-treesitter.configs',
build = ':TSUpdate',
dependencies = {
'nvim-treesitter/nvim-treesitter-textobjects',
{ 'nvim-treesitter/nvim-treesitter-context', opts = { enable = false } },
'JoosepAlviste/nvim-ts-context-commentstring',
'RRethy/nvim-treesitter-endwise',
'windwp/nvim-ts-autotag',
'andymass/vim-matchup',
},
cmd = {
'TSUpdate',
'TSInstall',
'TSInstallInfo',
'TSModuleInfo',
'TSConfigInfo',
'TSUpdateSync',
},
keys = {
{ 'v', desc = 'Increment selection', mode = 'x' },
{ 'V', desc = 'Shrink selection', mode = 'x' },
},
---@type TSConfig
---@diagnostic disable-next-line: missing-fields
opts = {
highlight = { enable = true },
indent = { enable = true },
refactor = {
highlight_definitions = { enable = true },
highlight_current_scope = { enable = true },
},
-- See: https://github.com/RRethy/nvim-treesitter-endwise
endwise = { enable = true },
-- See: https://github.com/andymass/vim-matchup
matchup = {
enable = true,
include_match_words = true,
},
-- See: https://github.com/windwp/nvim-ts-autotag
autotag = {
enable = true,
-- Removed markdown due to errors
filetypes = {
'glimmer',
'handlebars',
'hbs',
'html',
'javascript',
'javascriptreact',
'jsx',
'rescript',
'svelte',
'tsx',
'typescript',
'typescriptreact',
'vue',
'xml',
},
},
-- See: https://github.com/JoosepAlviste/nvim-ts-context-commentstring
context_commentstring = { enable = true, enable_autocmd = false },
incremental_selection = {
enable = true,
keymaps = {
init_selection = false,
node_incremental = 'v',
scope_incremental = false,
node_decremental = 'V',
},
},
-- See: https://github.com/nvim-treesitter/nvim-treesitter-textobjects
textobjects = {
select = {
enable = true,
lookahead = true,
keymaps = {
['af'] = '@function.outer',
['if'] = '@function.inner',
['ac'] = '@class.outer',
['ic'] = '@class.inner',
['a,'] = '@parameter.outer',
['i,'] = '@parameter.inner',
},
},
move = {
enable = true,
set_jumps = true,
goto_next_start = {
['],'] = '@parameter.inner',
},
goto_previous_start = {
['[,'] = '@parameter.inner',
},
},
swap = {
enable = true,
swap_next = {
['>,'] = '@parameter.inner',
},
swap_previous = {
['<,'] = '@parameter.inner',
},
},
},
-- https://github.com/nvim-treesitter/nvim-treesitter#supported-languages
ensure_installed = {
'bash',
'comment',
'css',
'cue',
'diff',
'fish',
'fennel',
'git_config',
'git_rebase',
'gitcommit',
'gitignore',
'gitattributes',
'graphql',
'hcl',
'html',
'http',
'java',
'javascript',
'jsdoc',
'kotlin',
'lua',
'luadoc',
'luap',
'make',
'markdown',
'markdown_inline',
'nix',
'perl',
'php',
'pug',
'regex',
'ruby',
'rust',
'scala',
'scss',
'sql',
'svelte',
'terraform',
'todotxt',
'toml',
'tsx',
'typescript',
'vim',
'vimdoc',
'vue',
'zig',
},
},
},
}

276
lua/plex/plugins/ui.lua
View File

@ -8,106 +8,6 @@ return {
{ 'MunifTanjim/nui.nvim', lazy = false }, { 'MunifTanjim/nui.nvim', lazy = false },
{ 'rafi/tabstrip.nvim', lazy = false, priority = 98, opts = true }, { 'rafi/tabstrip.nvim', lazy = false, priority = 98, opts = true },
-----------------------------------------------------------------------------
{
'folke/noice.nvim',
event = 'VeryLazy',
dependencies = {
'MunifTanjim/nui.nvim',
'rcarriga/nvim-notify',
'nvim-treesitter/nvim-treesitter',
},
-- stylua: ignore
keys = {
{ '<S-Enter>', function() require('noice').redirect(tostring(vim.fn.getcmdline())) end, mode = 'c', desc = 'Redirect Cmdline' },
{ '<leader>Snl', function() require('noice').cmd('last') end, desc = 'Noice Last Message' },
{ '<leader>Snh', function() require('noice').cmd('history') end, desc = 'Noice History' },
{ '<leader>Sna', function() require('noice').cmd('all') end, desc = 'Noice All' },
{ '<c-f>', function() if not require('noice.lsp').scroll(4) then return '<c-f>' end end, silent = true, expr = true, desc = 'Scroll forward', mode = {'i', 'n', 's'} },
{ '<c-b>', function() if not require('noice.lsp').scroll(-4) then return '<c-b>' end end, silent = true, expr = true, desc = 'Scroll backward', mode = {'i', 'n', 's'}},
},
---@type NoiceConfig
opts = {
lsp = {
override = {
['vim.lsp.util.convert_input_to_markdown_lines'] = true,
['vim.lsp.util.stylize_markdown'] = true,
['cmp.entry.get_documentation'] = true,
},
},
messages = {
view_search = false,
},
routes = {
-- See :h ui-messages
{
filter = { event = 'msg_show', find = '%d+L, %d+B$' },
view = 'mini',
},
{
filter = { event = 'msg_show', find = '^Hunk %d+ of %d+$' },
view = 'mini',
},
{
filter = { event = 'notify', find = '^No code actions available$' },
view = 'mini',
},
{
filter = { event = 'notify', find = '^No information available$' },
opts = { skip = true },
},
{
filter = { event = 'msg_show', find = '^%d+ change;' },
opts = { skip = true },
},
{
filter = { event = 'msg_show', find = '^%d+ %a+ lines' },
opts = { skip = true },
},
{
filter = { event = 'msg_show', find = '^%d+ lines yanked$' },
opts = { skip = true },
},
{
filter = { event = 'msg_show', kind = 'emsg', find = 'E490' },
opts = { skip = true },
},
{
filter = { event = 'msg_show', kind = 'quickfix' },
view = 'mini',
},
{
filter = { event = 'msg_show', kind = 'search_count' },
view = 'mini',
},
{
filter = { event = 'msg_show', kind = 'wmsg' },
view = 'mini',
},
},
presets = {
bottom_search = true,
command_palette = true,
long_message_to_split = true,
lsp_doc_border = true,
},
commands = {
all = {
view = 'split',
opts = { enter = true, format = 'details' },
filter = {},
},
},
---@type NoiceConfigViews
views = {
mini = {
zindex = 100,
win_options = { winblend = 0 },
},
},
},
},
----------------------------------------------------------------------------- -----------------------------------------------------------------------------
{ {
'stevearc/dressing.nvim', 'stevearc/dressing.nvim',
@ -125,95 +25,6 @@ return {
end, end,
}, },
-----------------------------------------------------------------------------
{
'SmiteshP/nvim-navic',
keys = {
{
'<Leader>tf',
function()
if vim.b.navic_winbar then
vim.b.navic_winbar = false
vim.opt_local.winbar = ''
else
vim.b.navic_winbar = true
vim.opt_local.winbar = '%#NavicIconsFile# %t %* '
.. "%{%v:lua.require'nvim-navic'.get_location()%}"
end
end,
desc = 'Toggle structure panel',
},
},
init = function()
vim.g.navic_silence = true
---@param client lsp.Client
---@param buffer integer
require('plex.lib.utils').on_attach(function(client, buffer)
if client.server_capabilities.documentSymbolProvider then
require('nvim-navic').attach(client, buffer)
end
end)
end,
opts = function()
return {
separator = '',
highlight = true,
icons = require('plex.config').icons.kinds,
}
end,
},
-----------------------------------------------------------------------------
{
'rcarriga/nvim-notify',
event = 'VeryLazy',
keys = {
{
'<leader>un',
function()
require('notify').dismiss({ silent = true, pending = true })
end,
desc = 'Dismiss all Notifications',
},
},
opts = {
timeout = 3000,
max_height = function()
return math.floor(vim.o.lines * 0.75)
end,
max_width = function()
return math.floor(vim.o.columns * 0.75)
end,
},
init = function()
-- When noice is not enabled, install notify on VeryLazy
local Util = require('plex.lib.utils')
if not Util.has('noice.nvim') then
Util.on_very_lazy(function()
vim.notify = require('notify')
end)
end
end,
},
-----------------------------------------------------------------------------
{
'chentoast/marks.nvim',
dependencies = 'lewis6991/gitsigns.nvim',
event = 'FileType',
keys = {
{ 'm/', '<cmd>MarksListAll<CR>', desc = 'Marks from all opened buffers' },
},
opts = {
sign_priority = { lower = 10, upper = 15, builtin = 8, bookmark = 20 },
bookmark_1 = { sign = '󰈼' }, -- ⚐ ⚑ 󰈻 󰈼 󰈽 󰈾 󰈿 󰉀
mappings = {
annotate = 'm<Space>',
},
},
},
----------------------------------------------------------------------------- -----------------------------------------------------------------------------
{ {
'lukas-reineke/indent-blankline.nvim', 'lukas-reineke/indent-blankline.nvim',
@ -226,8 +37,6 @@ return {
disable_with_nolist = true, disable_with_nolist = true,
show_foldtext = false, show_foldtext = false,
char_priority = 100, char_priority = 100,
show_current_context = true,
show_current_context_start = false,
filetype_exclude = { filetype_exclude = {
'lspinfo', 'lspinfo',
'checkhealth', 'checkhealth',
@ -255,89 +64,4 @@ return {
event = { 'BufReadPost', 'BufNewFile' }, event = { 'BufReadPost', 'BufNewFile' },
config = true, config = true,
}, },
-----------------------------------------------------------------------------
{
't9md/vim-quickhl',
keys = {
{
'<Leader>mt',
'<Plug>(quickhl-manual-this)',
mode = { 'n', 'x' },
desc = 'Highlight word',
},
},
},
-----------------------------------------------------------------------------
{
'kevinhwang91/nvim-bqf',
ft = 'qf',
cmd = 'BqfAutoToggle',
event = 'QuickFixCmdPost',
opts = {
auto_resize_height = false,
func_map = {
tab = 'st',
split = 'sv',
vsplit = 'sg',
stoggleup = 'K',
stoggledown = 'J',
stogglevm = '<Space>',
ptoggleitem = 'p',
ptoggleauto = 'P',
ptogglemode = 'zp',
pscrollup = '<C-b>',
pscrolldown = '<C-f>',
prevfile = 'gk',
nextfile = 'gj',
prevhist = '<S-Tab>',
nexthist = '<Tab>',
},
preview = {
auto_preview = true,
should_preview_cb = function(bufnr)
-- file size greater than 100kb can't be previewed automatically
local filename = vim.api.nvim_buf_get_name(bufnr)
local fsize = vim.fn.getfsize(filename)
if fsize > 100 * 1024 then
return false
end
return true
end,
},
},
},
-----------------------------------------------------------------------------
{
'uga-rosa/ccc.nvim',
event = 'FileType',
keys = {
{ '<Leader>cp', '<cmd>CccPick<CR>', desc = 'Color-picker' },
},
opts = {
highlighter = {
auto_enable = true,
lsp = true,
excludes = { 'lazy', 'mason', 'help', 'neo-tree' },
},
},
},
-----------------------------------------------------------------------------
{
'itchyny/calendar.vim',
cmd = 'Calendar',
init = function()
vim.g.calendar_google_calendar = 1
vim.g.calendar_google_task = 1
vim.g.calendar_cache_directory = vim.fn.stdpath('data') .. '/calendar'
end,
},
} }